dcp.c

大量的汇编程序源代码

               break;

            case CONN_INITIALIZE:
               hostp = NULL;

               if ( locked )
                  UnlockSystem();

               m_state = getsystem(recvgrade);
               if ( hostp != NULL )
                  remote_stats.save_hstatus = hostp->hstatus;
               break;

            case CONN_CHECKTIME:
               sendgrade = checktime(flds[FLD_CCTIME]);

               if ( (override_grade && sendgrade) || callnow )
                  sendgrade = recvgrade;

               if ( !CallWindow( sendgrade ))
                  m_state = CONN_INITIALIZE;
               else if ( LockSystem( hostp->hostname , B_UUCICO))
               {
                  dialed = TRUE;
                  time(&hostp->hstats->ltime);
                                 /* Save time of last attempt to call   */
                  hostp->hstatus = autodial;
                  m_state = CONN_MODEM;
               }
               else
                  m_state = CONN_INITIALIZE;

               break;

            case CONN_MODEM:
               if (getmodem(flds[FLD_TYPE]))
                  m_state = CONN_DIALOUT;
               else {
                  hostp->hstatus = invalid_device;
                  m_state = CONN_INITIALIZE;
               }
               break;

            case CONN_DIALOUT:

               if ( !IsNetwork() && suspend_other(TRUE, M_device ) < 0 )
               {
                  hostp->hstatus =  nodevice;
                  m_state = CONN_INITIALIZE;    // Try next system
               }
               else
                  m_state = callup( );
               break;

            case CONN_PROTOCOL:
               m_state = startup_server( (char)
                                          (bflag[F_SYMMETRICGRADES] ?
                                          sendgrade  : recvgrade) );
               break;

            case CONN_SERVER:
               m_state = process( poll_mode, recvgrade );
               Contacted = TRUE;
               break;

            case CONN_TERMINATE:
               m_state = sysend();
               if ( hostp != NULL )
               {
                  if (hostp->hstatus == inprogress)
                     hostp->hstatus = call_failed;
                  dcstats();
               }
               break;

            case CONN_DROPLINE:
               shutDown();
               UnlockSystem();
               suspend_other(FALSE, M_device);
               m_state = CONN_INITIALIZE;
               break;

            case CONN_EXIT:
               break;

            default:
               printmsg(0,"dcpmain: Unknown master state = %c",m_state );
               panic();
               break;
         } /* switch */

         if ( terminate_processing )
            m_state = CONN_EXIT;

      } /* while */

      fclose(fsys);

   }
   else { /* client mode */

      CONN_STATE s_state = CONN_INITIALIZE;
      CONN_STATE old_state = CONN_EXIT;

      if (!getmodem(E_inmodem))  /* Initialize modem configuration      */
         panic();                /* Avoid loop if bad modem name        */

      if ( ! IsNetwork() )
         suspend_init(M_device);

      while (s_state != CONN_EXIT )
      {
         printmsg(s_state == old_state ? 10 : 4 ,
                  "S state = %c", s_state);
         old_state = s_state;

         if (bflag[F_MULTITASK] &&
              (hostp != NULL ) &&
              (remote_stats.save_hstatus != hostp->hstatus ))
         {
            printmsg(2, "Updating status for host %s, status %d",
                        hostp->hostname ,
                        (int) hostp->hstatus );
            dcupdate();
            remote_stats.save_hstatus = hostp->hstatus;
         }

         switch (s_state) {
            case CONN_INITIALIZE:
               if ( hotuser == NULL )
                  s_state = CONN_ANSWER;
               else
                  s_state = CONN_HOTMODEM;
               break;

            case CONN_WAIT:
#if !defined(__TURBOC__) || defined(BIT32ENV)
              s_state = suspend_wait();
#else
              panic();                 // Why are we here?!
#endif
              break;

            case CONN_ANSWER:
               s_state = callin( exit_time );
               break;

            case CONN_HOTMODEM:
               s_state = callhot( hotbaud );
               break;

            case CONN_HOTLOGIN:
               if ( loginbypass( hotuser ) )
                  s_state = CONN_INITSTAT;
               else
                  s_state = CONN_DROPLINE;
               break;

            case CONN_LOGIN:
               if ( login( ) )
                  s_state = CONN_INITSTAT;
               else
                  s_state = CONN_DROPLINE;
               break;

            case CONN_INITSTAT:
               HostStatus();
               s_state = CONN_PROTOCOL;
               break;

            case CONN_PROTOCOL:
               s_state = startup_client(&sendgrade);
               break;

            case CONN_CLIENT:
               Contacted = TRUE;
               s_state = process( poll_mode, sendgrade );
               break;

            case CONN_TERMINATE:
               s_state = sysend();
               if ( hostp != NULL )
                  dcstats();
               break;

            case CONN_DROPLINE:
               shutDown();
               if ( locked )     /* Cause could get here w/o
                                    locking                    */
                  UnlockSystem();
               s_state = CONN_EXIT;
               break;

            case CONN_EXIT:
               break;

            default:
               printmsg(0,"dcpmain: Unknown slave state = %c",s_state );
               panic();
               break;
         } /* switch */

         if ( terminate_processing )
            s_state = CONN_EXIT;

      } /* while */
   } /* else */

/*--------------------------------------------------------------------*/
/*                         Report our results                         */
/*--------------------------------------------------------------------*/

   if (!Contacted && (poll_mode == POLL_ACTIVE))
   {
      if (dialed)
         printmsg(0, "Could not connect to remote system.");
      else
         printmsg(0,
               "No work for requested system or wrong time to call.");
   }

   dcupdate();

   if (bflag[F_SYSLOG] && ! bflag[F_MULTITASK])
      fclose(syslog);

   return terminate_processing ? 100 : (Contacted ? 0 : 5);

} /*dcpmain*/


/*--------------------------------------------------------------------*/
/*    p r o c e s s                                                   */
/*                                                                    */
/*    The procotol state machine                                      */
/*--------------------------------------------------------------------*/

static CONN_STATE process( const POLL_MODE poll_mode, const char callgrade )
{
   boolean master  = ( poll_mode == POLL_ACTIVE );
   boolean aborted = FALSE;
   XFER_STATE state =  master ? XFER_SENDINIT : XFER_RECVINIT;
   XFER_STATE old_state = XFER_EXIT;
                              /* Initialized to any state but the
                                 original value of "state"           */
   XFER_STATE save_state = XFER_EXIT;

/*--------------------------------------------------------------------*/
/*  Yea old state machine for the high level file transfer procotol   */
/*--------------------------------------------------------------------*/

   while( state != XFER_EXIT )
   {
      printmsg(state == old_state ? 14 : 4 ,
               "process: Machine state is = %c", state );
      old_state = state;

      if ( terminate_processing != aborted )
      {
         aborted = terminate_processing;
         state = XFER_ABORT;
      }

      switch( state )
      {

         case XFER_SENDINIT:  /* Initialize outgoing protocol        */
            state = sinit();
            break;

         case XFER_RECVINIT:  /* Initialize Receive protocol         */
            state = rinit();
            break;

         case XFER_MASTER:    /* Begin master mode                   */
            master = TRUE;
            state = XFER_NEXTJOB;
            break;

         case XFER_SLAVE:     /* Begin slave mode                    */
            master = FALSE;
            state = XFER_RECVHDR;
            break;

         case XFER_NEXTJOB:   /* Look for work in local queue        */
            state = scandir( rmtname, callgrade );
            break;

         case XFER_REQUEST:   /* Process next file in current job
                                 in queue                            */
            state = newrequest();
            break;

         case XFER_PUTFILE:   /* Got local tranmit request           */
            state = ssfile();
            break;

         case XFER_GETFILE:   /* Got local tranmit request           */
            state = srfile();
            break;

         case XFER_SENDDATA:  /* Remote accepted our work, send data */
            state = sdata();
            break;

         case XFER_SENDEOF:   /* File xfer complete, send EOF        */
            state = seof( master );
            break;

         case XFER_FILEDONE:  /* Receive or transmit is complete     */
            state = master ? XFER_REQUEST : XFER_RECVHDR;
            break;

         case XFER_NOLOCAL:   /* No local work, remote have any?     */
            state = sbreak();
            break;

         case XFER_NOREMOTE:  /* No remote work, local have any?     */
            state = schkdir( poll_mode == POLL_ACTIVE, callgrade );
            break;

         case XFER_RECVHDR:   /* Receive header from other host      */
            state = rheader();
            break;

         case XFER_TAKEFILE:  /* Set up to receive remote requested
                                 file transfer                       */
            state = rrfile();
            break;

         case XFER_GIVEFILE:  /* Set up to transmit remote
                                 requuest file transfer              */
            state = rsfile();
            break;

         case XFER_RECVDATA:  /* Receive file data from other host   */
            state = rdata();
            break;

         case XFER_RECVEOF:
            state = reof();
            break;

         case XFER_LOST:      /* Lost the other host, flame out      */
            printmsg(0,"process: Connection lost to %s, "
                       "previous system state = %c",
                       rmtname, save_state );
            hostp->hstatus = call_failed;
            state = XFER_EXIT;
            break;

         case XFER_ABORT:     /* Internal error, flame out           */
            printmsg(0,"process: Aborting connection to %s, "
                       "previous system state = %c",
                       rmtname, save_state );
            hostp->hstatus = call_failed;
            state = XFER_ENDP;
            break;

         case XFER_ENDP:      /* Terminate the protocol              */
            state = endp();
            break;

         default:
            printmsg(0,"process: Unknown state = %c, "
                       "previous system state = %c",
                       state, save_state );
            state = XFER_ABORT;
            break;
      } /* switch */

      save_state = old_state; /* Used only if we abort               */

   } /* while( state != XFER_EXIT ) */

/*--------------------------------------------------------------------*/
/*           Protocol is complete, terminate the connection           */
/*--------------------------------------------------------------------*/

   return CONN_TERMINATE;

} /* process */