nsh_telnetd.c

這是一個實時嵌入式作業系統 實作了MCS51 ARM等MCU

                    case TELNET_DO:
                      pstate->tn_state = STATE_DO;
                      break;

                    case TELNET_DONT:
                      pstate->tn_state = STATE_DONT;
                      break;

                    default:
                      pstate->tn_state = STATE_NORMAL;
                      break;
                  }
              }
            break;

          case STATE_WILL:
            /* Reply with a DONT */

            nsh_sendopt(pstate, TELNET_DONT, ch);
            pstate->tn_state = STATE_NORMAL;
            break;

          case STATE_WONT:
            /* Reply with a DONT */

            nsh_sendopt(pstate, TELNET_DONT, ch);
            pstate->tn_state = STATE_NORMAL;
            break;

          case STATE_DO:
            /* Reply with a WONT */

            nsh_sendopt(pstate, TELNET_WONT, ch);
            pstate->tn_state = STATE_NORMAL;
            break;

          case STATE_DONT:
            /* Reply with a WONT */

            nsh_sendopt(pstate, TELNET_WONT, ch);
            pstate->tn_state = STATE_NORMAL;
            break;

          case STATE_NORMAL:
            if (ch == TELNET_IAC)
              {
                pstate->tn_state = STATE_IAC;
              }
            else
              {
                nsh_putchar(pstate, ch);
              }
            break;
        }
    }
  return OK;
}

/****************************************************************************
 * Name: nsh_connection
 *
 * Description:
 *   Each time a new connection to port 23 is made, a new thread is created
 *   that begins at this entry point.  There should be exactly one argument
 *   and it should be the socket descriptor (+1).
 *
 ****************************************************************************/

static void *nsh_connection(void *arg)
{
  struct telnetd_s *pstate = (struct telnetd_s *)malloc(sizeof(struct telnetd_s));
  int               sockfd = (int)arg;
  int               ret    = ERROR;

  dbg("[%d] Started\n", sockfd);

  /* Verify that the state structure was successfully allocated */

  if (pstate)
    {
      /* Initialize the thread state structure */

      memset(pstate, 0, sizeof(struct telnetd_s));
      pstate->tn_sockfd = sockfd;
      pstate->tn_state  = STATE_NORMAL;

      /* Output a greeting */

      nsh_output(pstate, "NuttShell (NSH)\n");

      /* Loop processing each TELNET command */

      do
        {
          /* Display the prompt string */

          nsh_output(pstate, g_nshprompt);
          nsh_flush(pstate);

          /* Read a buffer of data from the TELNET client */

          ret = recv(pstate->tn_sockfd, pstate->tn_iobuffer, CONFIG_EXAMPLES_NSH_IOBUFFER_SIZE, 0);
          if (ret > 0)
            {

              /* Process the received TELNET data */

              nsh_dumpbuffer("Received buffer", pstate->tn_iobuffer, ret);
              ret = nsh_receive(pstate, ret);
            }
        }
      while (ret >= 0 && pstate->tn_state != STATE_CLOSE);
      dbg("[%d] ret=%d tn_state=%d\n", sockfd, ret, pstate->tn_state);

      /* End of command processing -- Clean up and exit */

      free(pstate);
    }

  /* Exit the task */

  dbg("[%d] Exitting\n", sockfd);
  close(sockfd);
  pthread_exit(NULL);
}

/****************************************************************************
 * Public Functions
 ****************************************************************************/

/****************************************************************************
 * Name: nsh_telnetmain
 *
 * Description:
 *   This is the main processing thread for telnetd.  It never returns
 *   unless an error occurs
 *
 ****************************************************************************/

int nsh_telnetmain(void)
{
 struct in_addr addr;
#if defined(CONFIG_EXAMPLES_NSH_DHCPC) || defined(CONFIG_EXAMPLES_NSH_NOMAC)
 uint8 mac[IFHWADDRLEN];
#endif

/* Many embedded network interfaces must have a software assigned MAC */

#ifdef CONFIG_EXAMPLES_NSH_NOMAC
  mac[0] = 0x00;
  mac[1] = 0xe0;
  mac[2] = 0xb0;
  mac[3] = 0x0b;
  mac[4] = 0xba;
  mac[5] = 0xbe;
  uip_setmacaddr("eth0", mac);
#endif

  /* Set up our host address */

#if !defined(CONFIG_EXAMPLES_NSH_DHCPC)
  addr.s_addr = HTONL(CONFIG_EXAMPLES_NSH_IPADDR);
#else
  addr.s_addr = 0;
#endif
  uip_sethostaddr("eth0", &addr);

  /* Set up the default router address */

  addr.s_addr = HTONL(CONFIG_EXAMPLES_NSH_DRIPADDR);
  uip_setdraddr("eth0", &addr);

  /* Setup the subnet mask */

  addr.s_addr = HTONL(CONFIG_EXAMPLES_NSH_NETMASK);
  uip_setnetmask("eth0", &addr);

#if defined(CONFIG_EXAMPLES_NSH_DHCPC)
  /* Set up the resolver */

  resolv_init();
#endif

#if defined(CONFIG_EXAMPLES_NSH_DHCPC)
  /* Get the MAC address of the NIC */

  uip_getmacaddr("eth0", mac);

  /* Set up the DHCPC modules */

  handle = dhcpc_open(&mac, IFHWADDRLEN);

  /* Get an IP address */

  if (handle)
    {
        struct dhcpc_state ds;
        (void)dhcpc_request(handle, &ds);
        uip_sethostaddr("eth1", &ds.ipaddr);
        if (ds.netmask.s_addr != 0)
          {
            uip_setnetmask("eth0", &ds.netmask);
          }
        if (ds.default_router.s_addr != 0)
          {
            uip_setdraddr("eth0", &ds.default_router);
          }
        if (ds.dnsaddr.s_addr != 0)
          {
            resolv_conf(&ds.dnsaddr);
          }
        dhcpc_close(handle);
    }
#endif

  /* Execute nsh_connection on each connection to port 23 */

  uip_server(HTONS(23), nsh_connection, CONFIG_EXAMPLES_NSH_STACKSIZE);
  return OK;
}

/****************************************************************************
 * Name: nsh_telnetout
 *
 * Description:
 *   Print a string to the remote shell window.
 *
 *   This function is implemented by the shell GUI / telnet server and
 *   can be called by the shell back-end to output a string in the
 *   shell window. The string is automatically appended with a linebreak.
 *
 ****************************************************************************/

int nsh_telnetout(FAR void *handle, const char *fmt, ...)
{
  struct telnetd_s *pstate = (struct telnetd_s *)handle;
  int nbytes = pstate->tn_sndlen;
  int len;
  va_list ap;

  /* Put the new info into the buffer.  Here we are counting on the fact that
   * no output strings will exceed NSH_MAX_LINELEN!
   */

  va_start(ap, fmt);
  vsnprintf(&pstate->tn_iobuffer[nbytes],
            (CONFIG_EXAMPLES_NSH_IOBUFFER_SIZE - 1) - nbytes, fmt, ap);
  va_end(ap);

  /* Get the size of the new string just added and the total size of
   * buffered data
   */

  len     = strlen(&pstate->tn_iobuffer[nbytes]);
  nbytes += len;

  /* Expand any terminating \n to \r\n */

  if (nbytes < (CONFIG_EXAMPLES_NSH_IOBUFFER_SIZE - 2) &&
      pstate->tn_iobuffer[nbytes-1] == '\n')
    {
      pstate->tn_iobuffer[nbytes-1] = ISO_cr;
      pstate->tn_iobuffer[nbytes]   = ISO_nl;
      pstate->tn_iobuffer[nbytes+1] = '\0';
      nbytes++;
    }
  pstate->tn_sndlen = nbytes;

  /* Flush to the network if the buffer does not have room for one more
   * maximum length string.
   */

  if (nbytes > CONFIG_EXAMPLES_NSH_IOBUFFER_SIZE - NSH_MAX_LINELEN)
    {
      nsh_flush(pstate);
    }

  return len;
}

/****************************************************************************
 * Name: cmd_exit
 *
 * Description:
 *   Quit the shell instance
 *
 ****************************************************************************/

void cmd_exit(void *handle, int argc, char **argv)
{
  struct telnetd_s *pstate = (struct telnetd_s *)handle;
  pstate->tn_state = STATE_CLOSE;
}