tprx.c

一个使用IPX协议在两台机器间传送文件的程序

      if ( (tprx->flags & TP_FLAG_IS_LFN) == 0 )
      {
         tprx_SetFileName(tprx,
            tp_ecb_get_data_adr(tprx->rx_ecb[pos])+
               sizeof(tp_request_struct)+request->short_name_offset);
         /*
         printf("normal %s\n", tp_ecb_get_data_adr(tprx->rx_ecb[pos])+sizeof(tp_request_struct)+request->short_name_offset);
         */
      }
      else
      {
         tprx_SetFileName(tprx,
            tp_ecb_get_data_adr(tprx->rx_ecb[pos])+
               sizeof(tp_request_struct));
         /*
         puts("lfn");
         */
      }

      tprx_ListenECB(tprx, pos);
      tprx_SetState(tprx, tprx_state_gen_ack_request);
      if ( tprx->f_exist != 0 && (tprx->flags&TP_FLAG_IS_NO_USER_CHECK) == 0 )
      {
         printf("local file '%s' exists, overwrite (y,n,a)? ",
            tprx->f_name);
         fflush(stdout);
      }
   }
}

void tprx_state_gen_ack_request(tprx_type tprx)
{
   tp_ack_request ack_request;

   tp_debug_out("tprx_state_gen_ack_request");

   ack_request = (tp_ack_request)tp_get_blk_data_adr(tprx->tx_data);
   ack_request->adr = *ipx_get_local_net_number();
   ack_request->exist = tprx->f_exist;
   ack_request->flags = tprx->flags;

   tp_set_blk_id(tprx->tx_data, TP_ID_ACK_REQUEST);

   tprx_SendECB(tprx);

   tprx_SetState(tprx, tprx_state_chk_ack_request);
}

void tprx_state_chk_ack_request(tprx_type tprx)
{
   tp_debug_out("tprx_state_chk_ack_request");

   if ( tprx->f_exist != 0 && (tprx->flags&TP_FLAG_IS_NO_USER_CHECK) == 0 )
   {
      tprx_WaitSend(tprx,
         tprx_state_user_check,
         tprx_state_gen_ack_request,
         tprx->large_delay);
   }
   else
   {
      tprx_WaitSend(tprx,
         tprx_state_wait_file_start,
         tprx_state_gen_ack_request,
         tprx->large_delay);
   }
}

void tprx_state_user_check(tprx_type tprx)
{
   int pos;
   if ( tprx_CheckTime(tprx) == 0 )
      return;
   tprx->f_is_skip = 0;
   if ( kbhit() != 0 )
   {
      int c = getch();
      switch(c)
      {
         case 'n':
         case 'N':
            printf("%c\n", c);
            tprx->f_is_skip = 1;
            tprx_SetState(tprx, tprx_state_gen_file_start);
            return;
         case 'a':
         case 'A':
            printf("%c\n", c);
            tprx_SetFlag(tprx, TP_FLAG_IS_NO_USER_CHECK);
            tprx_DoPAux(tprx, TP_MSG_PSTART);
            tprx_SetState(tprx, tprx_state_gen_file_start);
            return;
         case 'y':
         case 'Y':
         case 'j':
         case 'J':
            printf("%c\n", c);
            tprx_DoPAux(tprx, TP_MSG_PSTART);
            tprx_SetState(tprx, tprx_state_gen_file_start);
            return;
         case 27:
            tprx_Error(tprx, "user escape", 1);
            return;

      }
   }
   tprx_ListenExcept(tprx, TP_ID_FILE_START, TP_ID_FILE_END);
   pos = tprx_SearchId(tprx, TP_ID_FILE_START);
   if ( pos >= 0 )
   {
      printf("y/a\n");
      /* tprx_ListenECB(tprx, pos); */
      tprx_DoPAux(tprx, TP_MSG_PSTART);
      tprx_SetState(tprx, tprx_state_wait_file_start);
      return;
   }
   pos = tprx_SearchId(tprx, TP_ID_FILE_END);
   if ( pos >= 0 )
   {
      printf("n\n");
      tprx_SetState(tprx, tprx_state_gen_ack_file_end);
      tprx_ListenECB(tprx, pos);
      return;
   }


}

void tprx_state_gen_file_start(tprx_type tprx)
{
   tp_file_start file_start;

   tp_debug_out("tprx_state_gen_file_start");

   file_start = (tp_file_start)tp_get_blk_data_adr(tprx->tx_data);
   file_start->is_skip_file = tprx->f_is_skip;
   file_start->flags = tprx->flags;

   tp_set_blk_id(tprx->tx_data, TP_ID_FILE_START);
   tprx_SendECB(tprx);

   tprx_SetState(tprx, tprx_state_chk_file_start);
}

void tprx_state_chk_file_start(tprx_type tprx)
{
   tp_debug_out("tprx_state_chk_file_start");

   tprx_WaitSend(tprx,
      tprx_state_wait_file_start,
      tprx_state_gen_file_start,
      tprx->small_delay);
}

void tprx_state_wait_file_start(tprx_type tprx)
{
   int pos;

   /* tp_debug_out("tprx_state_wait_file_start"); */

   tprx_ListenExcept(tprx, TP_ID_FILE_START, TP_ID_FILE_END);
   pos = tprx_SearchId(tprx, TP_ID_FILE_START);
   if ( pos >= 0 )
   {
      tp_file_start file_start;
      file_start = (tp_file_start)tp_ecb_get_data_adr(tprx->rx_ecb[pos]);
      if ( file_start->is_skip_file != 0 )
      {
         tprx_SetState(tprx, tprx_state_none);
      }
      else
      {
         tprx_OpenFile(tprx);
         tprx_DoPAux(tprx, TP_MSG_PSTART);
         tprx_SetState(tprx, tprx_state_gen_ack_file_start);
         tprx->f_start = clock();
      }
      tprx_ListenECB(tprx, pos);
      return;
   }
   pos = tprx_SearchId(tprx, TP_ID_FILE_END);
   if ( pos >= 0 )
   {
      tprx_SetState(tprx, tprx_state_gen_ack_file_end);
      tprx_ListenECB(tprx, pos);
      return;
   }

   /* user may jump here... so time check is at the end */
   if ( tprx_CheckTime(tprx) == 0 )
      return;

}

void tprx_state_gen_ack_file_start(tprx_type tprx)
{
   tp_debug_out("tprx_state_gen_ack_file_start");

   tp_set_blk_id(tprx->tx_data, TP_ID_ACK_FILE_START);
   tprx_SendECB(tprx);
   tprx_SetState(tprx, tprx_state_chk_ack_file_start);
}

void tprx_state_chk_ack_file_start(tprx_type tprx)
{
   tp_debug_out("tprx_state_chk_ack_file_start");

   tprx_WaitSend(tprx,
      tprx_state_wait_block_start,
      tprx_state_gen_ack_file_start,
      tprx->large_delay);
}

void tprx_state_wait_block_start(tprx_type tprx)
{
   int pos;

   tp_debug_out("tprx_state_wait_block_start");

   if ( tprx_CheckTime(tprx) == 0 )
      return;
   tprx_ListenExcept(tprx, TP_ID_BLOCK_START, TP_ID_FILE_END);

   pos = tprx_SearchId(tprx, TP_ID_BLOCK_START);
   if ( pos >= 0 )
   {
      if ( tprx->f_pos < tprx->f_len || tprx->f_len == 0 )
      {
         tp_block_start block_start;
         block_start = (tp_block_start)tp_ecb_get_data_adr(tprx->rx_ecb[pos]);
         tprx_DoPAux(tprx, TP_MSG_PDATA);
         tprx_InitPool(tprx, (int)block_start->cnt);
         tprx_SetState(tprx, tprx_state_gen_ack_block_start);
      }
      tprx_ListenECB(tprx, pos);
   }
   pos = tprx_SearchId(tprx, TP_ID_FILE_END);
   if ( pos >= 0 )
   {
      if ( tprx->f_is_write_data != 0 )
         tprx_Write(tprx);
      tprx_DoPAux(tprx, TP_MSG_PDATA);
      tprx_DoPAux(tprx, TP_MSG_PEND);
      tprx_CloseFile(tprx);
      tprx_SetState(tprx, tprx_state_gen_ack_file_end);
      tprx_ListenECB(tprx, pos);
   }
}

void tprx_state_gen_ack_block_start(tprx_type tprx)
{
   tp_debug_out("tprx_state_gen_ack_block_start");

   tp_set_blk_id(tprx->tx_data, TP_ID_ACK_BLOCK_START);
   tprx_SendECB(tprx);
   tprx_SetState(tprx, tprx_state_chk_ack_block_start);
}

void tprx_state_chk_ack_block_start(tprx_type tprx)
{
   tp_debug_out("tprx_state_chk_ack_block_start");

   tprx_WaitSend(tprx,
      tprx_state_wait_data,
      tprx_state_gen_ack_block_start,
      tprx->small_delay);
}

void tprx_state_wait_data(tprx_type tprx)
{
   int pos;

   /* tp_debug_out("tprx_state_wait_data"); */

   if ( tprx->f_is_write_data != 0 )
      tprx_Write(tprx);
   if ( tprx_IsAnyPresent(tprx) == 0 )
      if ( tprx_CheckTime(tprx) == 0 )
         return;
   pos = tprx_SearchId(tprx, TP_ID_ERROR);
   if ( pos >= 0 )
   {
      static char s[80];
      sprintf(s, "remote error: '%s'", tp_ecb_get_data_adr(tprx->rx_ecb[pos]));
      tprx_Error(tprx, s, 0);
      tprx_ListenECB(tprx, pos);
      return;
   }
   pos = tprx_SearchId(tprx, TP_ID_TERMINATE);
   if ( pos >= 0 )
   {
      tprx_Error(tprx, "wait data: received kill signal", 1);
      tprx_ListenECB(tprx, pos);
      return;
   }

   /* remove illegal blocks */
   tprx_ListenExcept(tprx, TP_ID_DATA, TP_ID_BLOCK_END);

   pos = tprx_SearchId(tprx, TP_ID_DATA);
   if ( pos >= 0 )
   {
      tp_data d;
      d = (tp_data)tp_ecb_get_data_adr(tprx->rx_ecb[pos]);
      tprx_CopyMemoryToPool(tprx,
         d->no,
         tp_ecb_get_data_adr(tprx->rx_ecb[pos])+sizeof(tp_data_struct),
         (size_t)(d->len));
      /*
      printf("(%d,%d/%d)", (int)d->no, tprx->b_in_cnt, tprx->b_curr_cnt);
      */
      tprx_ListenECB(tprx, pos);
   }
   else
   {
      pos = tprx_SearchId(tprx, TP_ID_BLOCK_END);
      if ( pos >= 0 )
      {
         tp_debug_out("tprx_state_wait_data:TP_ID_BLOCK_END");
         /*
         printf("TP_ID_BLOCK_END at pos %d found, missed cnt: %d\n",
            pos, tprx->b_curr_cnt-tprx->b_in_cnt);
         */
         tprx_ListenECB(tprx, pos);
         if ( tprx->b_curr_cnt == tprx->b_in_cnt )
         {
            tp_block_end block_end;
            block_end = (tp_block_end)tp_ecb_get_data_adr(tprx->rx_ecb[pos]);
            tprx->f_remote_crc = block_end->crc;
            tprx->f_is_write_data = 1;
            tprx_SetState(tprx, tprx_state_gen_ack_block_end);
         }
         else
         {
            tprx_MakeMissedList(tprx);
            tprx_SetState(tprx, tprx_state_gen_missed_blocks);
         }
      }
      else
      {
         if ( tprx_CheckTime(tprx) == 0 )
            return;
      }
   }
}

void tprx_state_gen_missed_blocks(tprx_type tprx)
{
   tp_missed_blocks missed_blocks;

   /* tp_debug_out("tprx_state_gen_missed_blocks"); */
   /* printf("missed: %d (%ld)", (int)tprx->b_missed_cnt, (long)tprx->f_pos); */

   missed_blocks = (tp_missed_blocks)tp_get_blk_data_adr(tprx->tx_data);
   missed_blocks->cnt = tprx->b_missed_cnt;
   memcpy( tp_get_blk_data_adr(tprx->tx_data)+sizeof(tp_missed_blocks_struct),
      tprx->b_missed_list, tprx->b_missed_cnt*sizeof(short));

   tp_set_blk_id(tprx->tx_data, TP_ID_MISSED_BLOCKS);

   tprx_SendECB(tprx);

   tprx_SetState(tprx, tprx_state_chk_missed_blocks);
}

void tprx_state_chk_missed_blocks(tprx_type tprx)
{
   /* tp_debug_out("tprx_state_chk_missed_blocks"); */

   tprx_WaitSend(tprx,
      tprx_state_wait_data,
      tprx_state_gen_missed_blocks,
      tprx->small_delay);
}

void tprx_state_gen_ack_block_end(tprx_type tprx)
{
   tp_debug_out("tprx_state_gen_ack_block_end");

   tp_set_blk_id(tprx->tx_data, TP_ID_ACK_BLOCK_END);
   tprx_SendECB(tprx);
   tprx_SetState(tprx, tprx_state_chk_ack_block_end);
}

void tprx_state_chk_ack_block_end(tprx_type tprx)
{
   tp_debug_out("tprx_state_chk_ack_block_end");

   tprx_WaitSend(tprx,
      tprx_state_wait_block_start,
      tprx_state_gen_ack_block_end,
      tprx->small_delay);

}

void tprx_state_gen_ack_file_end(tprx_type tprx)
{
   tp_debug_out("tprx_state_gen_ack_file_end");

   tp_set_blk_id(tprx->tx_data, TP_ID_ACK_FILE_END);
   tprx_SendECB(tprx);
   tprx_SetState(tprx, tprx_state_chk_ack_file_end);
}

void tprx_state_chk_ack_file_end(tprx_type tprx)
{
   tp_debug_out("tprx_state_chk_ack_file_end");

   tprx_WaitSend(tprx,
      tprx_state_none2,
      tprx_state_gen_ack_file_end,
      tprx->large_delay);
}

void tprx_state_none2(tprx_type tprx)
{
   int pos;
   /* tp_debug_out("tprx_state_none2"); */
   if ( tprx_CheckTime(tprx) == 0 )
      return;
   pos = tprx_ListenAndSearch(tprx, TP_ID_REQUEST);
   if ( pos >= 0 )
   {
      tprx_SetState(tprx, tprx_state_none);
   }
}