xnu-792.25.20.tar.gz

[apple/xnu.git] / bsd / netat / aurp_ri.c

diff --git a/bsd/netat/aurp_ri.c b/bsd/netat/aurp_ri.c
index 44d8df2546f4040046bf0f657af0ac2dae586063..dd002da6649ff4dae32800ea5886c5290fdb1585 100644 (file)
--- a/bsd/netat/aurp_ri.c
+++ b/bsd/netat/aurp_ri.c
@@ -27,6 +27,9 @@
  *
  *     File: ri.c
  */
  *
  *     File: ri.c
  */

+ 
+#ifdef AURP_SUPPORT
+

 #include <sys/errno.h>
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/errno.h>
 #include <sys/types.h>
 #include <sys/param.h>


@@ -152,14 +155,12 @@ void AURPsndRIRsp(state)
        gbuf_t *m;
        aurp_hdr_t *hdrp;
        short len = 0;
        gbuf_t *m;
        aurp_hdr_t *hdrp;
        short len = 0;

-       int s, msize = 0;
+       int msize = 0;

 
 

-       ATDISABLE(s, aurpgen_lock);

 
        /* make sure we're in a valid state to send RI response */
        if ((state->snd_state == AURPSTATE_Unconnected) ||
                (state->snd_state == AURPSTATE_WaitingForRIAck2)) {
 
        /* make sure we're in a valid state to send RI response */
        if ((state->snd_state == AURPSTATE_Unconnected) ||
                (state->snd_state == AURPSTATE_WaitingForRIAck2)) {

-               ATENABLE(s, aurpgen_lock);

                return;
        }
 
                return;
        }
 


@@ -167,7 +168,6 @@ void AURPsndRIRsp(state)
        state->snd_state = AURPSTATE_WaitingForRIAck1;
 
        if (state->rsp_m == 0) {
        state->snd_state = AURPSTATE_WaitingForRIAck1;
 
        if (state->rsp_m == 0) {

-               ATENABLE(s, aurpgen_lock);

                msize = sizeof(aurp_hdr_t);
                if ((m = (gbuf_t *)gbuf_alloc(msize+AURP_MaxPktSize, PRI_MED)) == 0) {
                        timeout(AURPsndRIRsp_locked, state, AURP_RetryInterval*HZ);
                msize = sizeof(aurp_hdr_t);
                if ((m = (gbuf_t *)gbuf_alloc(msize+AURP_MaxPktSize, PRI_MED)) == 0) {
                        timeout(AURPsndRIRsp_locked, state, AURP_RetryInterval*HZ);


@@ -201,8 +201,6 @@ void AURPsndRIRsp(state)
        timeout(AURPsndRIRsp_locked, state, AURP_RetryInterval*HZ);
        state->snd_tmo = 1;
 
        timeout(AURPsndRIRsp_locked, state, AURP_RetryInterval*HZ);
        state->snd_tmo = 1;
 

-       if (msize == 0)
-               ATENABLE(s, aurpgen_lock);

 
        /* send the packet */
        if (m) {
 
        /* send the packet */
        if (m) {


@@ -229,13 +227,11 @@ void AURPsndRIUpd(state)
        short len = 0;
        int s, msize = 0;
 
        short len = 0;
        int s, msize = 0;
 

-       ATDISABLE(s, aurpgen_lock);

 
        /* make sure we're in a valid state to send update */
        if (state->snd_next_entry || (state->upd_m == 0) ||
                (state->snd_state == AURPSTATE_Unconnected) ||
                        (state->snd_state == AURPSTATE_WaitingForRIAck1)) {
 
        /* make sure we're in a valid state to send update */
        if (state->snd_next_entry || (state->upd_m == 0) ||
                (state->snd_state == AURPSTATE_Unconnected) ||
                        (state->snd_state == AURPSTATE_WaitingForRIAck1)) {

-               ATENABLE(s, aurpgen_lock);

                return;
        }
 
                return;
        }
 


@@ -243,7 +239,6 @@ void AURPsndRIUpd(state)
        state->snd_state = AURPSTATE_WaitingForRIAck2;
 
        if (state->snd_tmo == 0) {
        state->snd_state = AURPSTATE_WaitingForRIAck2;
 
        if (state->snd_tmo == 0) {

-               ATENABLE(s, aurpgen_lock);

                msize = sizeof(aurp_hdr_t);
                m = state->upd_m;
                len = gbuf_len(m);
                msize = sizeof(aurp_hdr_t);
                m = state->upd_m;
                len = gbuf_len(m);


@@ -264,8 +259,6 @@ void AURPsndRIUpd(state)
        timeout(AURPsndRIUpd_locked, state, AURP_RetryInterval*HZ);
        state->snd_tmo = 1;
 
        timeout(AURPsndRIUpd_locked, state, AURP_RetryInterval*HZ);
        state->snd_tmo = 1;
 

-       if (msize == 0)
-               ATENABLE(s, aurpgen_lock);

 
        /* send the packet */
        if (m) {
 
        /* send the packet */
        if (m) {


@@ -283,12 +276,10 @@ void AURPrcvRIReq(state, m)
        aurp_hdr_t *hdrp = (aurp_hdr_t *)gbuf_rptr(m);
        int s;
 
        aurp_hdr_t *hdrp = (aurp_hdr_t *)gbuf_rptr(m);
        int s;
 

-       ATDISABLE(s, aurpgen_lock);

 
        /* make sure we're in a valid state to accept it */
        if ((state->snd_state == AURPSTATE_Unconnected) ||
                        (state->snd_state == AURPSTATE_WaitingForRIAck2)) {
 
        /* make sure we're in a valid state to accept it */
        if ((state->snd_state == AURPSTATE_Unconnected) ||
                        (state->snd_state == AURPSTATE_WaitingForRIAck2)) {

-               ATENABLE(s, aurpgen_lock);

                dPrintf(D_M_AURP, D_L_WARNING, ("AURPrcvRIReq: unexpected request\n"));
                gbuf_freem(m);
                return;
                dPrintf(D_M_AURP, D_L_WARNING, ("AURPrcvRIReq: unexpected request\n"));
                gbuf_freem(m);
                return;


@@ -296,7 +287,6 @@ void AURPrcvRIReq(state, m)
 
        /* check for the correct connection id */
        if (hdrp->connection_id != state->snd_connection_id) {
 
        /* check for the correct connection id */
        if (hdrp->connection_id != state->snd_connection_id) {

-               ATENABLE(s, aurpgen_lock);

                dPrintf(D_M_AURP, D_L_WARNING,
                        ("AURPrcvRIReq: invalid connection id, r=%d, m=%d\n",
                        hdrp->connection_id, state->snd_connection_id));
                dPrintf(D_M_AURP, D_L_WARNING,
                        ("AURPrcvRIReq: invalid connection id, r=%d, m=%d\n",
                        hdrp->connection_id, state->snd_connection_id));


@@ -310,10 +300,8 @@ void AURPrcvRIReq(state, m)
                        gbuf_freem(state->rsp_m);
                        state->rsp_m = 0;
                }
                        gbuf_freem(state->rsp_m);
                        state->rsp_m = 0;
                }

-               ATENABLE(s, aurpgen_lock);

                AURPsndRIRsp(state);
                AURPsndRIRsp(state);

-       } else
-               ATENABLE(s, aurpgen_lock);
+       } 

 
        gbuf_freem(m);
 }
 
        gbuf_freem(m);
 }


@@ -324,13 +312,10 @@ void AURPrcvRIRsp(state, m)
        gbuf_t *m;
 {
        aurp_hdr_t *hdrp = (aurp_hdr_t *)gbuf_rptr(m);
        gbuf_t *m;
 {
        aurp_hdr_t *hdrp = (aurp_hdr_t *)gbuf_rptr(m);

-       int s;

 
 

-       ATDISABLE(s, aurpgen_lock);

 
        /* make sure we're in a valid state to accept it */
        if (state->rcv_state != AURPSTATE_WaitingForRIRsp) {
 
        /* make sure we're in a valid state to accept it */
        if (state->rcv_state != AURPSTATE_WaitingForRIRsp) {

-               ATENABLE(s, aurpgen_lock);

                dPrintf(D_M_AURP, D_L_WARNING, ("AURPrcvRIRsp: unexpected response\n"));
                gbuf_freem(m);
                return;
                dPrintf(D_M_AURP, D_L_WARNING, ("AURPrcvRIRsp: unexpected response\n"));
                gbuf_freem(m);
                return;


@@ -338,7 +323,6 @@ void AURPrcvRIRsp(state, m)
 
        /* check for the correct connection id */
        if (hdrp->connection_id != state->rcv_connection_id) {
 
        /* check for the correct connection id */
        if (hdrp->connection_id != state->rcv_connection_id) {

-               ATENABLE(s, aurpgen_lock);

                dPrintf(D_M_AURP, D_L_WARNING,
                        ("AURPrcvRIRsp: invalid connection id, r=%d, m=%d\n",
                        hdrp->connection_id, state->rcv_connection_id));
                dPrintf(D_M_AURP, D_L_WARNING,
                        ("AURPrcvRIRsp: invalid connection id, r=%d, m=%d\n",
                        hdrp->connection_id, state->rcv_connection_id));


@@ -348,7 +332,6 @@ void AURPrcvRIRsp(state, m)
 
        /* check for the correct sequence number */
        if (hdrp->sequence_number != state->rcv_sequence_number) {
 
        /* check for the correct sequence number */
        if (hdrp->sequence_number != state->rcv_sequence_number) {

-               ATENABLE(s, aurpgen_lock);

                if ( ((state->rcv_sequence_number == AURP_FirstSeqNum) &&
                        (hdrp->sequence_number == AURP_LastSeqNum)) ||
                (hdrp->sequence_number == (state->rcv_sequence_number-1)) ) {
                if ( ((state->rcv_sequence_number == AURP_FirstSeqNum) &&
                        (hdrp->sequence_number == AURP_LastSeqNum)) ||
                (hdrp->sequence_number == (state->rcv_sequence_number-1)) ) {


@@ -364,7 +347,6 @@ void AURPrcvRIRsp(state, m)
        gbuf_rinc(m,sizeof(*hdrp));
        if (hdrp->flags & AURPFLG_LAST)
                state->rcv_state = AURPSTATE_Connected;
        gbuf_rinc(m,sizeof(*hdrp));
        if (hdrp->flags & AURPFLG_LAST)
                state->rcv_state = AURPSTATE_Connected;

-       ATENABLE(s, aurpgen_lock);

 
        dPrintf(D_M_AURP, D_L_INFO, ("AURPrcvRIRsp: len=%ld\n", gbuf_len(m)));
 
 
        dPrintf(D_M_AURP, D_L_INFO, ("AURPrcvRIRsp: len=%ld\n", gbuf_len(m)));
 


@@ -457,12 +439,10 @@ void AURPrcvRIAck(state, m)
        gbuf_t *dat_m;
        aurp_hdr_t *hdrp = (aurp_hdr_t *)gbuf_rptr(m);
        unsigned char snd_state;
        gbuf_t *dat_m;
        aurp_hdr_t *hdrp = (aurp_hdr_t *)gbuf_rptr(m);
        unsigned char snd_state;

-       int s;

        int flag;
 
        dPrintf(D_M_AURP, D_L_INFO, ("AURPrcvRIAck: state=%d\n",
                state->snd_state));
        int flag;
 
        dPrintf(D_M_AURP, D_L_INFO, ("AURPrcvRIAck: state=%d\n",
                state->snd_state));

-       ATDISABLE(s, aurpgen_lock);

 
        /* make sure we're in a valid state to accept it */
        snd_state = state->snd_state;
 
        /* make sure we're in a valid state to accept it */
        snd_state = state->snd_state;


@@ -492,7 +472,6 @@ void AURPrcvRIAck(state, m)
 
                /* update state info */
                state->snd_state = AURPSTATE_Connected;
 
                /* update state info */
                state->snd_state = AURPSTATE_Connected;

-               ATENABLE(s, aurpgen_lock);

 
                if (state->snd_next_entry) /* more RI responses to send? */
                        AURPsndRIRsp(state);
 
                if (state->snd_next_entry) /* more RI responses to send? */
                        AURPsndRIRsp(state);


@@ -502,8 +481,7 @@ void AURPrcvRIAck(state, m)
                        AURPsndZRsp(state, dat_m, flag);
                else if (dat_m)
                        gbuf_freem(dat_m);
                        AURPsndZRsp(state, dat_m, flag);
                else if (dat_m)
                        gbuf_freem(dat_m);

-       } else
-               ATENABLE(s, aurpgen_lock);
+       } 

 
        gbuf_freem(m);
 }
 
        gbuf_freem(m);
 }


@@ -831,17 +809,14 @@ void AURPrtupdate(entry, ev)
                                (!(state->snd_sui & AURPFLG_ND))) continue;
                if ((ev == AURPEV_NetDistChange) &&
                                (!(state->snd_sui & AURPFLG_NDC))) continue;
                                (!(state->snd_sui & AURPFLG_ND))) continue;
                if ((ev == AURPEV_NetDistChange) &&
                                (!(state->snd_sui & AURPFLG_NDC))) continue;

-               ATDISABLE(s, aurpgen_lock);

          if ((state->snd_state != AURPSTATE_Unconnected) &&
                        (state->snd_state != AURPSTATE_WaitingForRIAck2)) {
                if ((m = state->upd_m) == 0) {
                        /*
                         * we don't have the RI update buffer yet, allocate one
                         */
          if ((state->snd_state != AURPSTATE_Unconnected) &&
                        (state->snd_state != AURPSTATE_WaitingForRIAck2)) {
                if ((m = state->upd_m) == 0) {
                        /*
                         * we don't have the RI update buffer yet, allocate one
                         */

-                       ATENABLE(s, aurpgen_lock);

                        if ((m = (gbuf_t *)gbuf_alloc(msize+AURP_MaxPktSize, PRI_HI)) == 0)
                                continue;
                        if ((m = (gbuf_t *)gbuf_alloc(msize+AURP_MaxPktSize, PRI_HI)) == 0)
                                continue;

-                       ATDISABLE(s, aurpgen_lock);

                        state->upd_m = m;
                        gbuf_rinc(m,msize);
                        gbuf_wset(m,0);
                        state->upd_m = m;
                        gbuf_rinc(m,msize);
                        gbuf_wset(m,0);


@@ -859,11 +834,10 @@ void AURPrtupdate(entry, ev)
                 * if the RI update buffer is full, send the RI update now
                 */
                if (gbuf_len(m) > (AURP_MaxPktSize-6)) {
                 * if the RI update buffer is full, send the RI update now
                 */
                if (gbuf_len(m) > (AURP_MaxPktSize-6)) {

-                       ATENABLE(s, aurpgen_lock);

                        AURPsndRIUpd(state);
                        continue;
                }
          }
                        AURPsndRIUpd(state);
                        continue;
                }
          }

-               ATENABLE(s, aurpgen_lock);

        }
 }
        }
 }

+