#help_index "Comm"

#define RMT_MAX_PKT_LEN	64  //Must be less then PKT_SYNC
#define RMT_PKT_ACK	0xA5
#define RMT_PKT_NACK	0x5A
#define RMT_PKT_SYNC	0xA3
#define RMT_PKT_SYNC2	0xA7
#define RMT_PKT_CHAR	0xA4
#define RMT_PKT_REQUEST	0xA6
#define RMT_PKT_RESET	0xA8

#define RMT_FILE_ACK	0x87566565

#define RMT_RQST_NONE		0x00
#define RMT_RQST_GETMSG		0x01
#define RMT_RQST_TX_FILE	0x02
#define RMT_RQST_RX_FILE	0x03
#define RMT_RQST_TX_BUF		0x04
#define RMT_RQST_RX_BUF		0x05
#define RMT_RQST_EXE_LOCAL	0x06
#define RMT_RQST_PUTS_CNT	0x07

#define RMT_NUM_RQST_TYPES	0x08

#define RMT_CHAR_DELAY		(JIFFY_FREQ/50)
#define RMT_TX_TIMEOUT_DELAY	(JIFFY_FREQ)
#define RMT_RX_TIMEOUT_DELAY	(JIFFY_FREQ)
#define RMT_NULL_MSG_DELAY	(JIFFY_FREQ/20)

public void RmtFlushRxFifo(LTChnl *chnl)
{
  if (!chnl || !chnl->type) return;
  U1FifoFlush(comm_Rx_fifos[chnl->port]);
  if (Bt(&comm_flags[chnl->port],COMMf_INCOMING_XOFFED)) {
    Bts(&comm_flags[chnl->port],COMMf_INCOMING_XOFFED2);
    Bts(&comm_flags[chnl->port],COMMf_INCOMING_XOFFED3);
    chnl->PutChar(chnl,CH_XON);
  }
}

public I8 RmtTxFifoCnt(LTChnl *chnl)
{
  if (!chnl || !chnl->type) return 0;
  return U1FifoCnt(comm_Tx_fifos[chnl->port]);
}

public void RmtWaitTxDone(LTChnl *chnl)
{
  U8 base=comm_base[chnl->port];
  if (!chnl || !chnl->type) return;
  while (RmtTxFifoCnt(chnl))
    SwapInNext;
  while (Bt(&comm_flags[chnl->port],COMMf_OUTGOING_XOFFED))
    SwapInNext;
  while (Bt(&comm_flags[chnl->port],COMMf_TX_XOFF))
    SwapInNext;
  while (Bt(&comm_flags[chnl->port],COMMf_TX_XON))
    SwapInNext;
  while (!(InP(base+UART_LSR) & 0x20))
    SwapInNext;
}

public void RmtFlushTxFifo(LTChnl *chnl)
{
  U8 base=comm_base[chnl->port];
  if (!chnl || !chnl->type) return;
  U1FifoFlush(comm_Tx_fifos[chnl->port]);
  RmtWaitTxDone(chnl);
}

void RmtReset(LTChnl *chnl)
{
  RmtFlushTxFifo(chnl);
  RmtFlushRxFifo(chnl);
  comm_flags[chnl->port]=0;
}



public void RmtPrintF(LTChnl *chnl,I1 *src,...)
{
  I1 *buf,*ptr;
  if (!chnl || !chnl->type) return;
  buf=SPrintFJoin(NULL,src,argc,argv);
  ptr=buf;
  while (*ptr)
    chnl->PutChar(chnl,*ptr++);
  Free(buf);
}

public I8 RmtRxFifoCnt(LTChnl *chnl)
{
  if (!chnl || !chnl->type) return 0;
  return U1FifoCnt(comm_Rx_fifos[chnl->port]);
}

public U1 RmtGetChar(LTChnl *chnl)
{
  if (!chnl || !chnl->type)
    return 0;
  return CommGetChar(chnl->port);
}

public BoolU4 RmtScanChar(LTChnl *chnl,U1 *ch)
{
  if (!chnl || !chnl->type)
    return 0;
  return CommScanChar(chnl->port,ch);
}
U8 RmtTxPktU1(LTChnl *chnl,U1 b)
{
  if (!chnl || !chnl->type) return 0;
  if (b==CH_XOFF || b==CH_XON ||
      b==CH_ESC || b==RMT_PKT_CHAR ||
      b==RMT_PKT_REQUEST ||
      b==RMT_PKT_RESET) {
    chnl->PutChar(chnl,CH_ESC);
    chnl->PutChar(chnl,b^0x80);
    return 2;
  } else {
    chnl->PutChar(chnl,b);
    return 1;
  }
}

BoolU8 RmtRxPktU1(LTChnl *chnl,U1 *b,
  U8 timeout_jiffies,BoolU4 *esc=NULL)
{
  U1 b1;
  U8 timeout;
  *b=RMT_PKT_NACK;
  if (esc)
    *esc=FALSE;
  if (!chnl || !chnl->type)
    return FALSE;
  timeout=Jiffies+timeout_jiffies;
  while (Jiffies<timeout) {
    if (chnl->ScanChar(chnl,&b1)) {
      if (b1==CH_ESC) {
	timeout=Jiffies+timeout_jiffies;
	while (Jiffies<timeout) {
	  if (chnl->ScanChar(chnl,&b1)) {
	    *b=b1^0x80;
	    if (esc) *esc=TRUE;
	    return TRUE;
	  }
	  SwapInNext;
	}
	return FALSE;
      } else {
	if (b1==RMT_PKT_RESET) {
	  RmtReset(chnl);
	  throw(EXCP_RESET);
	}
	*b=b1;
	return TRUE;
      }
    }
    SwapInNext;
  }
  return FALSE;
}

#define ERR_DELAY	1

void RmtTxPkt(LTChnl *chnl,U1 *p,U8 size,U8 rqst=RMT_RQST_NONE,
     U8 timeout_delay=0)
{ //zero timeout_delay=none
  U1 b,xsum;
  U8 i,timeout_jiffy;
  if (!chnl || !chnl->type) return;

  if (!timeout_delay && (Fs->rmt_chnl==chnl || Fs->local_chnl==chnl)) {
    timeout_delay=RMT_TX_TIMEOUT_DELAY;
    if (Fs->rmt_chnl==chnl &&
      chnl->pkt_rx_jiffy+RMT_NULL_MSG_DELAY<<1<Jiffies)
      timeout_delay=RMT_NULL_MSG_DELAY<<1;
  }
  if (timeout_delay)
    timeout_jiffy=Jiffies+timeout_delay;
  else
    timeout_jiffy=MAX_I8;

  if (rqst) {
rt_err1:
    if (Jiffies>timeout_jiffy)
      throw(EXCP_TIMEOUT);
    RmtFlushTxFifo(chnl);
    RmtFlushRxFifo(chnl);
    chnl->PutChar(chnl,RMT_PKT_REQUEST);
    RmtWaitTxDone(chnl);
    if (RmtScanChar(chnl,&b)) {
      Sleep(ERR_DELAY);
      goto rt_err1;
    }
    RmtTxPktU1(chnl,rqst);
    RmtWaitTxDone(chnl);
    RmtRxPktU1(chnl,&b,RMT_CHAR_DELAY);
    if (b!=(RMT_PKT_ACK^RMT_PKT_REQUEST^rqst)&0xFF) {
      Sleep(ERR_DELAY);
      goto rt_err1;
    }
  } else if (size==1) {
rt_err2:
    if (Jiffies>timeout_jiffy)
      throw(EXCP_TIMEOUT);
    RmtFlushTxFifo(chnl);
    RmtFlushRxFifo(chnl);
    chnl->PutChar(chnl,RMT_PKT_CHAR);
    RmtWaitTxDone(chnl);
    if (RmtScanChar(chnl,&b)) {
      Sleep(ERR_DELAY);
      goto rt_err2;
    }
    RmtTxPktU1(chnl,p[0]);
    RmtWaitTxDone(chnl);
    RmtRxPktU1(chnl,&b,RMT_CHAR_DELAY);
    if (b!=RMT_PKT_ACK^RMT_PKT_CHAR^p[0]) {
      Sleep(ERR_DELAY);
      goto rt_err2;
    }
  } else {
rt_err3:
    if (Jiffies>timeout_jiffy)
      throw(EXCP_TIMEOUT);
    RmtFlushTxFifo(chnl);
    RmtFlushRxFifo(chnl);
    RmtTxPktU1(chnl,RMT_PKT_SYNC);
    RmtWaitTxDone(chnl);
    if (RmtScanChar(chnl,&b)) {
      Sleep(ERR_DELAY);
      goto rt_err3;
    }
    RmtTxPktU1(chnl,RMT_PKT_SYNC2);
    RmtWaitTxDone(chnl);
    RmtRxPktU1(chnl,&b,RMT_CHAR_DELAY);
    if (b!=RMT_PKT_ACK^RMT_PKT_SYNC) {
      Sleep(ERR_DELAY);
      goto rt_err3;
    }
    if (RmtScanChar(chnl,&b)) {
      Sleep(ERR_DELAY);
      goto rt_err3;
    }
    RmtTxPktU1(chnl,size);
    RmtWaitTxDone(chnl);
    RmtRxPktU1(chnl,&b,RMT_CHAR_DELAY);
    if (b!=(RMT_PKT_ACK^size)&0xFF) {
      Sleep(ERR_DELAY);
      goto rt_err3;
    }
    xsum=0x3A;
    for (i=0;i<size;i++) {
      RmtTxPktU1(chnl,p[i]);
      if (RmtScanChar(chnl,&b))  {
	Sleep(ERR_DELAY);
	goto rt_err3;
      }
      xsum^=p[i];
    }
    while (RmtTxFifoCnt(chnl)) {
      if (RmtScanChar(chnl,&b)) {
	Sleep(ERR_DELAY);
	goto rt_err3;
      }
      SwapInNext;
    }
    RmtTxPktU1(chnl,xsum);
    RmtWaitTxDone(chnl);
    RmtRxPktU1(chnl,&b,RMT_CHAR_DELAY);
    if (b!=(RMT_PKT_ACK^xsum)&0xFF) {
      Sleep(ERR_DELAY);
      goto rt_err3;
    }
  }
  chnl->pkt_tx_jiffy=Jiffies;
}

void RmtRxPkt(LTChnl *chnl,U1 *p,U8 *size=NULL,U8 *rqst=NULL,
  U8 timeout_delay=0)
{ //zero timeout_delay=none
  U1 b,b1,xsum;
  U8 i=0,s,r,timeout_jiffy;
  BoolU4 esc;

  if (!chnl || !chnl->type) {
    if (size) *size=0;
    if (rqst) *rqst=0;
    return;
  }

  if (!timeout_delay && (Fs->rmt_chnl==chnl || Fs->local_chnl==chnl)) {
    timeout_delay=RMT_RX_TIMEOUT_DELAY;
    if (Fs->rmt_chnl==chnl &&
      chnl->pkt_rx_jiffy+RMT_NULL_MSG_DELAY<<1<Jiffies)
      timeout_delay=RMT_NULL_MSG_DELAY<<1;
  }
  if (timeout_delay)
    timeout_jiffy=Jiffies+timeout_delay;
  else
    timeout_jiffy=MAX_I8;

rr_start:
  RmtFlushTxFifo(chnl);
  if (RmtRxFifoCnt(chnl)>2)
    RmtFlushRxFifo(chnl);
  s=0;
  r=0;
  RmtRxPktU1(chnl,&b,RMT_CHAR_DELAY);

rr_cont:
  if (Jiffies>timeout_jiffy)
    throw(EXCP_TIMEOUT);
  RmtRxPktU1(chnl,&b1,RMT_CHAR_DELAY,&esc);
  if (b==RMT_PKT_REQUEST) {
    if (b1>=RMT_NUM_RQST_TYPES) {
      if (b1==RMT_PKT_REQUEST && !esc)
	goto rr_cont;
      else
	goto rr_err;
    }
    r=b1;
    s=0;
    if (RmtScanChar(chnl,&b))
      goto rt_err;
    RmtTxPktU1(chnl,RMT_PKT_ACK^RMT_PKT_REQUEST^b1);
    goto rr_exit;
  } else if (b==RMT_PKT_CHAR) {
    if (b1==RMT_PKT_CHAR && !esc)
      goto rr_cont;
    *p=b1;
    s=1;
    if (RmtScanChar(chnl,&b))
      goto rt_err;
    RmtTxPktU1(chnl,RMT_PKT_ACK^RMT_PKT_CHAR^b1);
    goto rr_exit;
  } else if (b==RMT_PKT_SYNC) {
    if (b1!=RMT_PKT_SYNC2) {
      if (b1==RMT_PKT_SYNC)
	goto rr_cont;
      else
	goto rr_err;
    }
    if (RmtScanChar(chnl,&b))
      goto rt_err;
    RmtTxPktU1(chnl,RMT_PKT_ACK^RMT_PKT_SYNC);
    RmtWaitTxDone(chnl);
    RmtRxPktU1(chnl,&s,RMT_CHAR_DELAY);
    if (s>RMT_MAX_PKT_LEN)
      goto rr_err;
    if (RmtScanChar(chnl,&b))
      goto rt_err;
    RmtTxPktU1(chnl,(RMT_PKT_ACK^s)&0xFF);
    RmtWaitTxDone(chnl);
    xsum=0x3A;
    for (i=0;i<s;i++) {
      if (!RmtRxPktU1(chnl,&p[i],RMT_CHAR_DELAY))
	goto rr_err;
      xsum^=p[i];
    }
    RmtRxPktU1(chnl,&b,RMT_CHAR_DELAY);
    if (b!=xsum)
      goto rr_err;
    if (RmtScanChar(chnl,&b))
      goto rt_err;
    RmtTxPktU1(chnl,(RMT_PKT_ACK^xsum)&0xFF);
    goto rr_exit;
  } else {
    if (++i & 3)
      goto rr_start;
    else
      goto rr_err;
  }
rr_err:
  RmtFlushTxFifo(chnl);
  RmtFlushRxFifo(chnl);
  RmtTxPktU1(chnl,RMT_PKT_NACK);
  RmtWaitTxDone(chnl);
  goto rr_start;

rr_exit:
  RmtWaitTxDone(chnl);
  if (size) *size=s;
  if (rqst) *rqst=r;
  chnl->pkt_rx_jiffy=Jiffies;
}

public void RmtTxBlk(LTChnl *chnl,U1 *buf,I8 cnt)
{
  U1 b[RMT_MAX_PKT_LEN];
  U8 size;
  if (!chnl || !chnl->type) return;
  while (cnt>0) {
    if (cnt<RMT_MAX_PKT_LEN)
      size=cnt;
    else
      size=RMT_MAX_PKT_LEN;
    MemCpy(b,buf,size);
    RmtTxPkt(chnl,b,size);
    cnt-=size;
    buf+=size;
    progress1=cnt;
  }
}

public U1 *RmtRxBlk(LTChnl *chnl,I8 cnt)
{
  U1 *result,*buf;
  U1 b[RMT_MAX_PKT_LEN];
  U8 size=0;
  if (!chnl || !chnl->type) return NULL;
  result=MAlloc(cnt);
  buf=result;
  while (cnt>0) {
    RmtRxPkt(chnl,b,&size);
    MemCpy(buf,b,size);
    cnt-=size;
    buf+=size;
    progress1=cnt;
  }
  return result;
}

public U8 RmtGetMsg(LTChnl *chnl,I8 *p1,I8 *p2)
{
  U8 cmd=0,size;
  U1 b[RMT_MAX_PKT_LEN];
  *p1=0;
  *p2=0;
  if (!chnl || !chnl->type)
    return 0;
  if (Jiffies<chnl->null_msg_jiffy)
    return 0;
  try {
    RmtTxPkt(chnl,NULL,0,RMT_RQST_GETMSG);
    RmtRxPkt(chnl,b,&size);
    if (size==sizeof(U8)*3) {
      cmd=b[0]><(U8);
      *p1=b[8]><(U8);
      *p2=b[16]><(U8);
    }
  } catch {
    if (Fs->except_argc==1) {
      if (Fs->except_argv[0]==EXCP_TIMEOUT)
	Fs->catch_except=TRUE;
    }
  }
  if (cmd)
    chnl->null_msg_jiffy=0;
  else
    chnl->null_msg_jiffy=Jiffies+RMT_NULL_MSG_DELAY;
  return cmd;
}

public void RmtSendMsg(LTChnl *chnl,U8 cmd,I8 p1,I8 p2)
{
  U1 b[RMT_MAX_PKT_LEN];
  if (!chnl || !chnl->type) return;
  if (cmd) {
    b[0]><(U8)=cmd;
    b[8]><(U8)=p1;
    b[16]><(U8)=p2;
    RmtTxPkt(chnl,b,sizeof(U8)*3);
  } else {
    RmtTxPkt(chnl,b,1);
    chnl->null_msg_cnt++;
  }
}

public BoolU4 RmtPutKey(I8 ch,U8 sc)
{
  nounusedwarn sc;
  if (ch && Fs->rmt_chnl) {
    try {
      RmtTxPkt(Fs->rmt_chnl,&ch,1);
    } catch {
      if (Fs->except_argc==1) {
	if (Fs->except_argv[0]==EXCP_TIMEOUT)
	  Fs->catch_except=TRUE;
      }
    }
  }
  return FALSE;
}

public void RmtTxBuf(LTChnl *chnl,U1 *buf,U8 size)
{
  if (!chnl || !chnl->type) return;
  if (buf) {
    RmtTxBlk(chnl,&size,sizeof(U8));
    RmtTxBlk(chnl,buf,size);
  }
}

public U1 *RmtRxBuf(LTChnl *chnl,U8 *size=NULL)
{
  U1 *buf;
  U8 *size2;
  if (size) *size=0;
  if (!chnl || !chnl->type) return NULL;
  size2=RmtRxBlk(chnl,sizeof(U8));
  buf=RmtRxBlk(chnl,*size2);
  if (size) *size=*size2;
  Free(size2);
  return buf;
}

public BoolU4 RmtTxFile(LTChnl *chnl,I1 *filename,
  BoolU4 raw=TRUE)
{
  U8 size,tries=3;
  U1 *buf;
  U4 *good;
  U1 b[RMT_MAX_PKT_LEN];
  LTDirEntry de;
  if (!chnl || !chnl->type) return;
start_tx:
  if (FindFile(filename,&de)) {
    buf=ReadFile(filename,&size,NULL,raw);
    if (buf) {
      RmtTxBuf(chnl,&de.start,LT_DIR_ENTRY_SIZE);
      RmtTxBuf(chnl,buf,size);
      Free(buf);
    }
  }
  RmtRxPkt(chnl,b,&size);
  good=b;
  if (size==4 && *good==RMT_FILE_ACK)
    return TRUE;
  else {
    if (!--tries) {
      coutln "Failed!";
      return FALSE;
    } else {
      coutln "Retry";
      goto start_tx;
    }
  }
}

public U8 RmtRxFile(LTChnl *chnl,I1 *filename,
  BoolU4 raw=TRUE)
{
  U8 size,tries=3;
  U4 good;
  U1 *buf,*buf1;
  LTDirEntry *de;
  if (!chnl || !chnl->type) return 0;
start_rx:
  good=0;
  buf1=RmtRxBuf(chnl);
  de=buf1-offset(LTDirEntry.start);
  if (buf=RmtRxBuf(chnl,&size)) {
    good=RMT_FILE_ACK;
    if (de->xsum) {
      if ((de->xsum^ArcCheckSum(buf,de->size))!=LT_XSUM)
	good=0;
    }
    if (good)
      WriteFile(filename,buf,size,de->datetime,de->attr,raw);
    else
      coutln "Bad XSUM";
    Free(buf);
  }
  Free(buf1);
  RmtTxPkt(chnl,&good,sizeof(BoolU4));
  if (!good) {
    if (!--tries) {
      coutln "Failed!";
      return 0;
    } else {
      coutln "Retry";
      goto start_rx;
    }
  } else
    return size;
}

public void RmtTxPutS(LTChnl *chnl,I1 *st)
{
  U8 len;
  if (!chnl || !chnl->type) return;
  if (st) {
    len=StrLen(st);
    if (len) {
      if (len>RMT_MAX_PKT_LEN) {
	RmtTxPkt(chnl,NULL,0,RMT_RQST_PUTS_CNT);
	RmtTxBuf(chnl,st,len+1);
      } else
	RmtTxBlk(chnl,st,len);
    }
  }
}

public void RmtTxPutChar(LTChnl *chnl,I8 ch)
{
  if (!chnl || !chnl->type) return;
  if (ch)
    RmtTxPkt(chnl,&ch,1);
}

public I1 *RmtRxPutS(LTChnl *chnl,U8 *rqst=NULL)
{
  U1 b[RMT_MAX_PKT_LEN];
  U8 size;
  U1 *buf=NULL;
  if (!chnl || !chnl->type) return NULL;
  if (RmtRxFifoCnt(chnl)>=2) {
    RmtRxPkt(chnl,b,&size,rqst);
    if (size) {
      buf=MAlloc(size+1);
      MemCpy(buf,b,size);
      buf[size]=0;
    } else
      buf=MAllocZ(1);
  }
  return buf;
}

public U1 *RmtRqstTxBuf()
{
//Remote must fill-in remote's chnl->tx_buf
//and remote's chnl->tx_size before calling.
  LTChnl *chnl=Fs->rmt_chnl;
  U1 *result;
  if (!chnl || !chnl->type) return NULL;
  RmtTxPkt(chnl,NULL,0,RMT_RQST_TX_BUF);
  result=RmtRxBuf(chnl);
  return result;
}

public void RmtRqstRxBuf(U1 *src_local_buf,U8 size)
{ //Dst buf address is placed in remote's chnl->rx_buf
  LTChnl *chnl=Fs->rmt_chnl;
  if (!chnl || !chnl->type) return;
  RmtTxPkt(chnl,NULL,0,RMT_RQST_RX_BUF);
  RmtTxBuf(chnl,src_local_buf,size);
}

public void RmtRqstTxFile(I1 *dst_local_filename,I1 *src_remote_filename)
{
  LTChnl *chnl=Fs->rmt_chnl;
  if (!chnl || !chnl->type) return;
  RmtTxPkt(chnl,NULL,0,RMT_RQST_TX_FILE);
  RmtTxBuf(chnl,src_remote_filename,StrLen(src_remote_filename)+1);
  RmtRxFile(chnl,dst_local_filename);
}

public void RmtRqstRxFile(I1 *src_local_filename,I1 *dst_remote_filename)
{
  LTChnl *chnl=Fs->rmt_chnl;
  if (!chnl || !chnl->type) return;
  RmtTxPkt(chnl,NULL,0,RMT_RQST_RX_FILE);
  RmtTxBuf(chnl,dst_remote_filename,StrLen(dst_remote_filename)+1);
  RmtTxFile(chnl,src_local_filename);
}

public void RmtRqstExeLocal(I1 *st)
{
  LTChnl *chnl=Fs->rmt_chnl;
  if (!chnl || !chnl->type) return;
  RmtTxPkt(chnl,NULL,0,RMT_RQST_EXE_LOCAL);
  RmtTxBuf(chnl,st,StrLen(st)+1);
}

public void TelnetHostOpen(LTChnl *chnl)
//Allows remote telnet user to control
//this task.  Will still allow local
//control.
{
  if (!chnl || !chnl->type) return;
  Fs->rmt_chnl=chnl;
}

public void TelnetHostClose()
{
  Fs->rmt_chnl=NULL;
}

public void TelnetGuestOpen(LTChnl *chnl)
{
  U8 i,cmd,p1,p2,rqst;
  U1 *st,*st2;
  BoolU4 cont=TRUE,msg_sent=TRUE;
  BoolU4 old_preempt=Preempt(OFF);
  if (!chnl || !chnl->type) return;
  Fs->local_chnl=chnl;
  coutln "$$BK 1$$CTRL-ALT-B to break$$BK 0$$";
  for (i=0;i<4;i++) {
    chnl->PutChar(chnl,RMT_PKT_RESET);
    chnl->PutChar(chnl,RMT_PKT_RESET);
    Sleep(100);
  }
  while (cont) {
    try {
    Fs->task_flags&=~(1<<TSSf_IDLE);
    SwapInNext;
    RmtReset(chnl);
    while (cont) {
      Fs->task_flags&=~(1<<TSSf_IDLE);
      if (st2=RmtRxPutS(chnl,&rqst)) {
	if (rqst!=RMT_RQST_GETMSG)
	  chnl->null_msg_cnt=0;
	switch (rqst) {
	  case RMT_RQST_NONE:
	    PutS(st2);
	    break;
	  case RMT_RQST_GETMSG:
	    if (msg_sent)
	      cmd=ScanMsg(&p1,&p2,
		1<<MSG_KEY_DOWN|
		1<<MSG_CMD|
		1<<MSG_KEY_UP);
	    msg_sent=FALSE;
	    if (cmd) {
	      if (cmd==MSG_KEY_DOWN &&
		p2&SCF_ALT && p2&SCF_CTRL &&
		p1==CH_CTRLB) {
		  RmtSendMsg(chnl,0,0,0);
		  msg_sent=TRUE;
 		  cont=FALSE;
		  break;
	      }
	    }
	    RmtSendMsg(chnl,cmd,p1,p2);
	    if (!cmd)
	      Fs->task_flags|=1<<TSSf_IDLE;
	    msg_sent=TRUE;
	    break;
	  case RMT_RQST_TX_FILE:
	    st=RmtRxBuf(chnl);
	    RmtTxFile(chnl,st);
	    Free(st);
	    break;
	  case RMT_RQST_RX_FILE:
	    st=RmtRxBuf(chnl);
	    RmtRxFile(chnl,st);
	    Free(st);
	    break;
	  case RMT_RQST_TX_BUF:
	    RmtTxBuf(chnl,chnl->tx_buf,chnl->tx_size);
	    break;
	  case RMT_RQST_RX_BUF:
	    chnl->rx_buf=RmtRxBuf(chnl);
	    break;
	  case RMT_RQST_EXE_LOCAL:
	    st=RmtRxBuf(chnl);
	    ExecuteStr(st);
	    Free(st);
	    break;
	  case RMT_RQST_PUTS_CNT:
	    Free(st2);
	    st2=RmtRxBuf(chnl);
	    PutS(st2);
	    break;
	}
	Free(st2);
	st2=NULL;
      } else {
	Fs->task_flags|=1<<TSSf_IDLE;
	SwapInNext;
      }
    }
    } catch {
      cont=FALSE;
      if (Fs->except_argc==1) {
	if (Fs->except_argv[0]==EXCP_TIMEOUT) {
	  Fs->catch_except=TRUE;
	  cont=TRUE;
	}
      }
      if (!cont) {
	Fs->local_chnl=NULL;
	Preempt(old_preempt);
      }
    }
  }
  Fs->local_chnl=NULL;
  Preempt(old_preempt);
}

BoolU8 RmtPutS(I1 *st)
{
  if (Fs->rmt_chnl) {
    try
      RmtTxPutS(Fs->rmt_chnl,st);
    catch {
      if (Fs->except_argc==1) {
	if (Fs->except_argv[0]==EXCP_TIMEOUT)
	  Fs->catch_except=TRUE;
      }
    }
  }
  return FALSE;
}

AddKeyDev(&RmtPutKey,&RmtPutS,0xA0000000);
#help_index ""