sessionmgr.c

Vista 核心Rally技术之-LLTD 实现源代码

                    CANCEL(ssn->ssn_InactivityTimer);
                    ssn->ssn_is_valid = FALSE;
                }
            }
        }
        /* In any case, reset (invalidate) this session */
        IF_TRACED(TRC_STATE)
            printf("smS[%X] (Pending): Leaving for Nascent.\n", (uint)evt->ssn);
        END_TRACE
        evt->ssn->ssn_state = smS_Nascent;
        CANCEL(evt->ssn->ssn_InactivityTimer);
        evt->ssn->ssn_is_valid = FALSE;
        packetio_invalidate_retxbuf();
        break;

      case evtHelloDelayTimeout:
	if (--(evt->ssn->ssn_count) == 0)
	{
            evt->ssn->ssn_state = smS_Complete;
            IF_TRACED(TRC_STATE)
              printf("smS[%X] (Pending): Leaving for Complete.\n", (uint)evt->ssn);
            END_TRACE
	}
	break;

      case evtPacketRcvd:
      case evtEmitRcvd:
      case evtBlockTimeout:
      case evtChargeTimeout:
      case evtEmitTimeout:
      default :
        IF_TRACED(TRC_STATE)
            printf("smS (Pending): Ignored event %s\n", smEvent_names[evt->evtType]);
        END_TRACE
        break;
    }

    return PROCESSING_COMPLETED;
}

/***********************  T E M P O R A R Y   S T A T E  ***********************/

static
enum sm_Status
smS_TemporaryHandler( protocol_event_t *evt )
{
    IF_TRACED(TRC_STATE)
        printf("smS (Temporary): Entered with event %s",smEvent_names[evt->evtType]);
        if (g_this_event.evtType==evtPacketRcvd)
        {
            printf(" (%s)\n",Topo_opcode_names[g_opcode]);
        } else {
            puts("");
        }
    END_TRACE

    switch (evt->evtType)
    {
      case evtInactivityTimeout:
      case evtResetRcvd:
      case evtHelloDelayTimeout:
        IF_TRACED(TRC_STATE)
            printf("smS[%X] (Temporary): Leaving for Nascent.\n", (uint)evt->ssn);
        END_TRACE
        evt->ssn->ssn_state = smS_Nascent;
        CANCEL(evt->ssn->ssn_InactivityTimer);
        evt->ssn->ssn_is_valid = FALSE;
        break;

      case evtPacketRcvd:
      case evtEmitRcvd:
      case evtDiscoverRcvd:

      case evtBlockTimeout:
      case evtChargeTimeout:
      case evtEmitTimeout:
      default:
        IF_TRACED(TRC_STATE)
            printf("smS (Temporary): Ignored event %s\n",smEvent_names[evt->evtType]);
        END_TRACE
        break;
    }

    return PROCESSING_COMPLETED;
}

/***********************  C O M P L E T E   S T A T E  ***********************/

static
enum sm_Status
smS_CompleteHandler ( protocol_event_t *evt )
{
    IF_TRACED(TRC_STATE)
        printf("smS (Complete): Entered with event %s",smEvent_names[evt->evtType]);
        if (g_this_event.evtType==evtPacketRcvd)
        {
            printf(" (%s)\n",Topo_opcode_names[g_opcode]);
        } else {
            puts("");
        }
    END_TRACE

    switch (evt->evtType)
    {
      case evtInactivityTimeout:
      case evtResetRcvd:
        /* is this session the topology session? */
        if (evt->ssn == g_topo_session  &&  g_topo_session->ssn_is_valid == TRUE)
        {
            /* Must reset the Temporary sessions, as well, then. */
            session_t   *ssn = &g_sessions[0];
            int i;
            for (i=0; i < MAX_NUM_SESSIONS; ssn++, i++)
            {
                if ( (ssn->ssn_is_valid) && (ssn->ssn_state==smS_Temporary) )
                {
                    IF_TRACED(TRC_STATE)
                        printf("smS[%X] (Temporary): Leaving for Nascent.\n", (uint)ssn);
                    END_TRACE
                    ssn->ssn_state = smS_Nascent;
                    CANCEL(ssn->ssn_InactivityTimer);
                    ssn->ssn_is_valid = FALSE;
                }
            }
            osl_set_promisc(g_osl, FALSE);
//!!            osl_set_arprx(FALSE, ts);
        }
        /* In any case, reset (invalidate) this session */
        IF_TRACED(TRC_STATE)
            printf("smS[%X] (Complete): Leaving for Nascent.\n", (uint)evt->ssn);
        END_TRACE
        evt->ssn->ssn_state = smS_Nascent;
        CANCEL(evt->ssn->ssn_InactivityTimer);
        evt->ssn->ssn_is_valid = FALSE;
        packetio_invalidate_retxbuf();
        break;

      case evtDiscoverRcvd:
        if (is_acking_me())
        {
//*/        DEBUG({puts("is acking me....");})

            evt->isAckingMe = TRUE;

            /* Discover-acking-changed-XID arc says we must reset the smT if this
             * event is associated with the topo-session. Then we process it as
             * the Discover, afterwards. */
            if (g_sequencenum  &&  evt->ssn->ssn_XID != g_sequencenum  &&  g_topo_session == evt->ssn)
            {
                bool_t  isActuallyInternal = g_this_event.isInternalEvt;

                IF_TRACED(TRC_PACKET)
                    printf("smS (Complete): Discover-ack, new XID (%d) != old XID (%d); resetting topo session....\n",
                           g_sequencenum, evt->ssn->ssn_XID);
                END_TRACE
                g_this_event.evtType = evtResetRcvd;
                g_this_event.isInternalEvt = TRUE;
                smT_process_event( &g_this_event );
                g_this_event.evtType = evtDiscoverRcvd;
                g_this_event.isInternalEvt = isActuallyInternal;
                IF_TRACED(TRC_PACKET)
                    printf("smS (Complete): After topo reset, re-creating the topo-session ptr....\n");
                END_TRACE
                g_topo_session = evt->ssn;
                /* Regardless of whether this is acking or not, we must accept the new XID, unless it's zero */
                evt->ssn->ssn_XID = g_sequencenum;
            }
            restart_inactivity_timer((evt->ssn->ssn_TypeOfSvc == ToS_TopologyDiscovery) ? TOPO_CMD_ACTIVITYTIMEOUT : TOPO_GENERAL_ACTIVITYTIMEOUT);
        } else {
            /* Discover-noack-changed-XID arc says we must reset the smT if this
             * event is associated with the topo-session. Then we process it as
             * the Discover, afterwards. */
            if (g_sequencenum  &&  evt->ssn->ssn_XID != g_sequencenum  &&  g_topo_session == evt->ssn)
            {
                bool_t  isActuallyInternal = g_this_event.isInternalEvt;

                IF_TRACED(TRC_PACKET)
                    printf("smS (Complete): Discover-noack, new XID (%d) != old XID (%d); resetting topo session....\n",
                           g_sequencenum, evt->ssn->ssn_XID);
                END_TRACE
                g_this_event.evtType = evtResetRcvd;
                g_this_event.isInternalEvt = TRUE;
                smT_process_event( &g_this_event );
                g_this_event.evtType = evtDiscoverRcvd;
                g_this_event.isInternalEvt = isActuallyInternal;
                IF_TRACED(TRC_PACKET)
                    printf("smS (Complete): After topo reset, re-creating the topo-session ptr....\n");
                END_TRACE
                g_topo_session = evt->ssn;
                /* Regardless of whether this is acking or not, we must accept the new XID, unless it's zero */
                evt->ssn->ssn_XID = g_sequencenum;
                IF_TRACED(TRC_STATE)
                    printf("smS[%X] (Complete): Leaving for Pending (No-ack, changed XID).\n", (uint)evt->ssn);
                END_TRACE
                evt->ssn->ssn_state = smS_Pending;
                restart_inactivity_timer(TOPO_HELLO_ACTIVITYTIMEOUT);
            } else {
                restart_inactivity_timer((evt->ssn->ssn_TypeOfSvc == ToS_TopologyDiscovery) ? TOPO_CMD_ACTIVITYTIMEOUT : TOPO_GENERAL_ACTIVITYTIMEOUT);
            }
        }
        break;

      case evtEmitRcvd:
      case evtPacketRcvd:
        restart_inactivity_timer((evt->ssn->ssn_TypeOfSvc == ToS_TopologyDiscovery) ? TOPO_CMD_ACTIVITYTIMEOUT : TOPO_GENERAL_ACTIVITYTIMEOUT);
        break;

      case evtBlockTimeout:
      case evtChargeTimeout:
      case evtEmitTimeout:
      case evtHelloDelayTimeout:
      default :
        IF_TRACED(TRC_STATE)
//*/            printf("smS (Complete): Ignored event %s\n",smEvent_names[evt->evtType]);
        END_TRACE
        break;
    }

    return PROCESSING_COMPLETED;
}


/***********************                             ***********************/
/***********************  S T A T E   M A C H I N E  ***********************/
/***********************                             ***********************/


enum sm_Status
smS_process_event( protocol_event_t *evt )
{
    IF_TRACED(TRC_STATE)
//*/        printf("smS_process_event: Entered with event %s\n",smEvent_names[evt->evtType]);
    END_TRACE

    if (evt->ssn == NULL)
    {
        IF_TRACED(TRC_STATE)
            printf("smS (no-state): Not dispatching - no session associated with event %s",
                   smEvent_names[evt->evtType]);
            if (g_this_event.evtType==evtPacketRcvd)
            {
                printf(" (%s)\n",Topo_opcode_names[g_opcode]);
            } else {
                puts("");
            }
        END_TRACE
        return PROCESSING_COMPLETED;
    }
    switch (evt->ssn->ssn_state)
    {
      case smS_Nascent:
        return smS_NascentHandler( evt );

      case smS_Pending:
        return smS_PendingHandler( evt );

      case smS_Temporary:
        return smS_TemporaryHandler( evt );

      case smS_Complete:
        return smS_CompleteHandler( evt );

      default:
        return PROCESSING_ABORTED;	/* Stop! smS in unknown state! */
    }
}