telnetd.c File Reference

#include "telnetd.h"

Include dependency graph for telnetd.c:

Go to the source code of this file.

Macros
#define	telnetd_printf   printf

Functions
int	kickoff_telnetd (void)
static BOOL WINAPI	Cleanup (DWORD dwControlType)
static BOOLEAN	StartSocketInterface (void)
static void	CreateSocket (void)
static void	WaitForConnect (void)
static void	UserLogin (int client_socket)
static DWORD WINAPI	UserLoginThread (LPVOID data)
static int	DoTelnetHandshake (int sock)
static int	ReceiveLine (int sock, char *buffer, int len, EchoMode echo)
static void	RunShell (client_t *client)
static DWORD WINAPI	MonitorChildThread (LPVOID data)
static DWORD WINAPI	WriteToPipeThread (LPVOID data)
static DWORD WINAPI	ReadFromPipeThread (LPVOID data)
static void	TerminateShell (client_t *client)
static VOID	ErrorExit (LPTSTR lpszMessage)

Variables
static BOOLEAN	bShutdown = 0
static BOOLEAN	bSocketInterfaceInitialised = 0
static int	sock

Macro Definition Documentation

telnetd_printf

#define telnetd_printf   printf

Definition at line 25 of file telnetd.c.

Function Documentation

Cleanup()

static BOOL WINAPI Cleanup ( DWORD  dwControlType )

static

Definition at line 69 of file telnetd.c.

{
  if (bSocketInterfaceInitialised) {
    telnetd_printf("Cleanup...\n");
    WSACleanup();
  }
  return 0;
}

CreateSocket()

static void CreateSocket ( void  )

static

Definition at line 102 of file telnetd.c.

{
   struct sockaddr_in sa;
 
   sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
   if (sock < 0)
     ErrorExit("Cannot create socket");
 
   memset(&sa, 0, sizeof(sa));
   sa.sin_family = AF_INET;
   sa.sin_addr.s_addr = INADDR_ANY;
   sa.sin_port = htons(TELNET_PORT);
 
   if (bind(sock, (struct sockaddr*) &sa, sizeof(sa)) != 0)
      ErrorExit("Cannot bind address to socket");
}

Referenced by kickoff_telnetd(), Test_ioctlsocket(), and Test_recv().

DoTelnetHandshake()

static int DoTelnetHandshake ( int  sock )

static

Definition at line 229 of file telnetd.c.

{
  int retval;
  int received;
  fd_set set;
  struct timeval timeout = { HANDSHAKE_TIMEOUT, 0 };
 
  char will_echo[]=
      IAC DONT ECHO
      IAC WILL ECHO
      IAC WILL NAWS
      IAC WILL SUPPRESS_GO_AHEAD
      IAC DO SUPPRESS_GO_AHEAD
      IAC DONT NEWENVIRON
      IAC WONT NEWENVIRON
      IAC WONT LINEMODE
      IAC DO NAWS
      IAC SB TERMINAL_TYPE "\x01" IAC SE
      ;
 
  unsigned char client_reply[256];
 
  if (send(sock, will_echo, sizeof(will_echo), 0) < 0) {   
    return -1;
  }
 
  /* Now wait for client response (and ignore it) */
  FD_ZERO(&set);
  FD_SET(sock, &set);
 
  do {
    retval = select(0, &set, NULL, NULL, &timeout);
    /* check for error */
    if (retval < 0) {
      return -1;
      /* check for timeout */
    } else if (retval == 0) {
      return 0;
    }
    /* no error and no timeout, we have data in our sock */
    received = recv(sock, (char *) client_reply, sizeof(client_reply), 0);
    if (received <= 0) {
     return -1;
    }
  } while (retval);
 
  return 0;
}

Referenced by UserLoginThread().

ErrorExit()

static VOID ErrorExit ( LPTSTR  lpszMessage )

static

Definition at line 647 of file telnetd.c.

{ 
   fprintf(stderr, "%s\n", lpszMessage);
   if (bSocketInterfaceInitialised) {
     telnetd_printf("WSAGetLastError=%d\n", WSAGetLastError());
     WSACleanup();
   }
   ExitProcess(0); 
} 

Referenced by AcpiDsExecBeginOp(), AcpiEvAsynchExecuteGpeMethod(), AcpiEvCreateGpeInfoBlocks(), AcpiEvDetectGpe(), AcpiInstallMethod(), AcpiNsConvertToReference(), AcpiNsInitializeDevices(), AcpiUtCopyEsimpleToIsimple(), AcpiUtCopyIelementToIelement(), AcpiUtUpdateObjectReference(), CreateSocket(), IopValidateID(), kickoff_telnetd(), MENU_TrackMenu(), RunShell(), StartSocketInterface(), URL_ParseUrl(), USBH_CreateDevice(), USBH_PortIdleNotificationCancelRoutine(), USBH_ResetDevice(), USBH_StartHubFdoDevice(), USBH_SyncGetHubDescriptor(), USBPORT_CreateDevice(), UserLogin(), and WaitForConnect().

kickoff_telnetd()

int kickoff_telnetd

(

void

)

Definition at line 48 of file telnetd.c.

{
  printf("Attempting to start Simple TelnetD\n");
 
//  DetectPlatform();
  SetConsoleCtrlHandler(Cleanup, 1);
 
  if (!StartSocketInterface())
    ErrorExit("Unable to start socket interface\n");
 
  CreateSocket();
 
  while(!bShutdown) {
    WaitForConnect();
  }
 
  WSACleanup();
  return 0;
}

Referenced by serv_main().

MonitorChildThread()

static DWORD WINAPI MonitorChildThread ( LPVOID  data )

static

Definition at line 461 of file telnetd.c.

{
  DWORD exitCode;
  client_t *client = (client_t *) data;
 
  telnetd_printf("Monitor thread running...\n");
 
  WaitForSingleObject(client->hProcess, INFINITE);
 
  GetExitCodeProcess(client->hProcess, &exitCode);
  telnetd_printf("Child process terminated with code %lx\n", exitCode);
 
  /* signal the other threads to give up */
  client->bTerminate = TRUE;
 
  Sleep(500);
 
  CloseHandle(client->hChildStdoutRd);
  CloseHandle(client->hChildStdinWr);       
  CloseHandle(client->hProcess);
 
  closesocket(client->socket);
 
  telnetd_printf("Waiting for all threads to give up..\n");
 
  while (client->bWriteToPipe || client->bReadFromPipe) {
    telnetd_printf(".");
    fflush(stdout);
    Sleep(1000);
  }
 
  telnetd_printf("Cleanup for user '%s'\n", client->userID);
  free(client);
  return 0;
}

Referenced by RunShell().

ReadFromPipeThread()

static DWORD WINAPI ReadFromPipeThread ( LPVOID  data )

static

Definition at line 545 of file telnetd.c.

{    
  DWORD dwRead;
  DWORD dwAvail;
  CHAR chBuf[BUFSIZE];
  CHAR txBuf[BUFSIZE*2];
  DWORD from,to;
  //char warning[] = "warning: rl_prep_terminal: cannot get terminal settings";
 
  client_t *client = (client_t *) data;
 
  while (!client->bTerminate && client->bWriteToPipe) {
    // Since we do not want to block, first peek...
    if (PeekNamedPipe(client->hChildStdoutRd, NULL, 0, NULL, &dwAvail, NULL) == 0) {
      telnetd_printf("Failed to peek in pipe\n");
      break;
    }
    if (dwAvail) {
      if( ! ReadFile( client->hChildStdoutRd, chBuf, BUFSIZE, &dwRead, NULL) ||
           dwRead == 0) {
        telnetd_printf("Failed to read from pipe\n");
        break;
      }
      for (from=0, to=0; from<dwRead; from++, to++) {
        txBuf[to] = chBuf[from];
        if (txBuf[to] == '\n') {
            txBuf[to] = '\r';
            to++;
            txBuf[to] = '\n';
        }
      }
      if (send(client->socket, txBuf, to, 0) < 0) {
         telnetd_printf("error writing to socket\n");
         break;    
      }
    }
    Sleep(100); /* Hmmm, oh well... what the heck! */
  }
 
  if (!client->bTerminate)
    TerminateShell(client);
 
  telnetd_printf("ReadFromPipeThread terminated\n");
 
  client->bReadFromPipe = FALSE;
  return 0;
}

Referenced by RunShell().

ReceiveLine()

static int ReceiveLine ( int  sock, char *  buffer, int  len, EchoMode  echo  )

static

Definition at line 289 of file telnetd.c.

{
  int            i = 0;
  int            retval;
  fd_set         set;
  struct timeval timeout = { 0, 100000 };
  char           del[3] = { BS, ' ', BS };
  char           asterisk[1] = { '*' };
 
  FD_ZERO(&set);
  FD_SET(sock, &set);
 
  memset(buffer, '\0', len);
 
  do {
    /* When we're in echo mode, we do not need a timeout */
    retval = select(0, &set, NULL, NULL, (echo ? NULL : &timeout) );
    /* check for error */
    if (retval < 0) {
      return -1;
      /* check for timeout */
    } else if (retval == 0) {
      /* return number of characters received so far */
      return i;
    }
    /* no error and no timeout, we have data in our sock */
    if (recv(sock, &buffer[i], 1, 0) <= 0) {
      return -1;
    }
    if ((buffer[i] == '\0') || (buffer[i] == LF)) {
      /* ignore null characters and linefeeds from DOS telnet clients */
      buffer[i] = '\0';
    } else if ((buffer[i] == DEL) || (buffer[i] == BS)) {
      /* handle delete and backspace */
      buffer[i] = '\0';
      if (echo) {
          if (i > 0) {
          i--;
          buffer[i] = '\0';
          if (send(sock, del, sizeof(del), 0) < 0) {
            return -1;
          }
        }
      } else {
        buffer[i] = BS;  /* Let shell process handle it */
          i++;
      }
    } else {
      /* echo typed characters */
      if (echo == Echo && send(sock, &buffer[i], 1, 0) < 0) {
        return -1;
      } else if (echo == Password && send(sock, asterisk, sizeof(asterisk), 0) < 0) {
        return -1;
      }
      if (buffer[i] == CR) {
        i++;
        buffer[i] = LF; /* append LF for DOS command processor */
        i++;
        return i;
      }
 
      i++;
    }    
  } while (i < len);
 
  return i;
}

Referenced by UserLoginThread(), and WriteToPipeThread().

RunShell()

static void RunShell ( client_t *  client )

static

Definition at line 360 of file telnetd.c.

{ 
   HANDLE                threadHandle;
   HANDLE                hChildStdinRd;
   HANDLE                hChildStdinWr;
   HANDLE                hChildStdoutRd;
   HANDLE                hChildStdoutWr;
   STARTUPINFO           si;
   PROCESS_INFORMATION   piProcInfo;
   SECURITY_ATTRIBUTES   saAttr;
   char cmd_path[MAX_PATH];
 
   if (!GetEnvironmentVariableA("COMSPEC", cmd_path, ARRAYSIZE(cmd_path)))
   {
      if (GetSystemDirectoryA(cmd_path, ARRAYSIZE(cmd_path)))
      {
         StringCchCatA(cmd_path, ARRAYSIZE(cmd_path), "\\cmd.exe");
      }
      else
      {
         ErrorExit("GetSystemDirectoryA failed\n");
      }
   }
 
   saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); 
   saAttr.bInheritHandle = TRUE; 
   saAttr.lpSecurityDescriptor = NULL; 
   
   // Create a pipe for the child process's STDOUT.  
   if (! CreatePipe(&hChildStdoutRd, &hChildStdoutWr, &saAttr, 0)) 
      ErrorExit("Stdout pipe creation failed\n");  
 
   if (! CreatePipe(&hChildStdinRd, &hChildStdinWr, &saAttr, 0)) 
      ErrorExit("Stdin pipe creation failed\n");  
 
 
   client->bTerminate = FALSE;
   client->bWriteToPipe = TRUE;
   client->bReadFromPipe = TRUE;
   client->hChildStdinWr = hChildStdinWr;   
   client->hChildStdoutRd = hChildStdoutRd;
 
 
   // Create the child process (the shell)
   telnetd_printf("Creating child process...\n");
 
   ZeroMemory( &si, sizeof(STARTUPINFO) );
   si.cb = sizeof(STARTUPINFO);  
 
   si.dwFlags = STARTF_USESTDHANDLES;
   si.hStdInput = hChildStdinRd;
   si.hStdOutput = hChildStdoutWr;
   si.hStdError = hChildStdoutWr;
 
   //si.dwFlags |= STARTF_USESHOWWINDOW;
   //si.wShowWindow = SW_SHOW;
 
   if (!CreateProcess(cmd_path,                  // executable module
                      NULL,                      // command line 
                      NULL,                      // process security attributes 
                      NULL,                      // primary thread security attributes 
                      TRUE,                      // handles are inherited 
                      DETACHED_PROCESS +         // creation flags 
                      CREATE_NEW_PROCESS_GROUP,
                      NULL,                      // use parent's environment 
                      NULL,                      // use parent's current directory 
                      &si,                       // startup info
                      &piProcInfo)) {
     ErrorExit("Create process failed");
   }
 
   client->hProcess = piProcInfo.hProcess;
   client->dwProcessId = piProcInfo.dwProcessId;
 
   telnetd_printf("New child created (groupid=%lu)\n", client->dwProcessId);
 
   // No longer need these in the parent...
   if (!CloseHandle(hChildStdoutWr)) 
     ErrorExit("Closing handle failed");  
 
   if (!CloseHandle(hChildStdinRd)) 
     ErrorExit("Closing handle failed");  
 
   threadHandle = CreateThread(NULL, 0, WriteToPipeThread, client, 0, NULL);
   if (threadHandle != NULL)
     CloseHandle(threadHandle);
 
   threadHandle = CreateThread(NULL, 0, ReadFromPipeThread, client, 0, NULL);
   if (threadHandle != NULL)
     CloseHandle(threadHandle);
 
   threadHandle = CreateThread(NULL, 0, MonitorChildThread, client, 0, NULL);
   if (threadHandle != NULL)
     CloseHandle(threadHandle);
} 

Referenced by UserLoginThread().

StartSocketInterface()

static BOOLEAN StartSocketInterface ( void  )

static

Definition at line 79 of file telnetd.c.

{
  WORD    wVersionRequested;
  WSADATA wsaData;
  int     err; 
 
  wVersionRequested = MAKEWORD( 2, 0 ); 
  err = WSAStartup(wVersionRequested, &wsaData);
  if (err != 0) {
    telnetd_printf("requested winsock version not supported\n");
    return 0;
  } 
 
  bSocketInterfaceInitialised = 1; /* for ErrorExit function */
 
  if ( wsaData.wVersion != wVersionRequested)
    ErrorExit("requested winsock version not supported\n");
 
  telnetd_printf("TelnetD, using %s\n", wsaData.szDescription);
  return 1;
}

Referenced by kickoff_telnetd().

TerminateShell()

static void TerminateShell ( client_t *  client )

static

Definition at line 594 of file telnetd.c.

{
    DWORD exitCode;
    DWORD dwWritten;
    char stop[] = "\003\r\nexit\r\n"; /* Ctrl-C + exit */
 
    GetExitCodeProcess(client->hProcess, &exitCode);
 
    if (exitCode == STILL_ACTIVE)
    {
        HANDLE hEvent = NULL;
        DWORD dwWaitResult;
 
        telnetd_printf("user shell still active, send Ctrl-Break to group-id %lu\n", client->dwProcessId );
 
        hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
 
        if (hEvent == NULL)
            printf("CreateEvent error\n");
 
        if (!GenerateConsoleCtrlEvent( CTRL_BREAK_EVENT, client->dwProcessId ))
            telnetd_printf("Failed to send Ctrl_break\n");
 
        if (!GenerateConsoleCtrlEvent( CTRL_C_EVENT, client->dwProcessId ))
            telnetd_printf("Failed to send Ctrl_C\n");
 
        if (!WriteFile(client->hChildStdinWr, stop, sizeof(stop), &dwWritten, NULL))
            telnetd_printf("Error writing to pipe\n");
 
        /* wait for our handler to be called */
        dwWaitResult=WaitForSingleObject(hEvent, 500);
 
        if (WAIT_FAILED==dwWaitResult)
            telnetd_printf("WaitForSingleObject failed\n");
 
        GetExitCodeProcess(client->hProcess, &exitCode);
        if (exitCode == STILL_ACTIVE) 
        {
            telnetd_printf("user shell still active, attempt to terminate it now...\n");
        
            if (hEvent != NULL) 
            {
                if (!CloseHandle(hEvent)) 
                   telnetd_printf("CloseHandle");
            }
            TerminateProcess(client->hProcess, 0);
        }
        TerminateProcess(client->hProcess, 0);
    }
    TerminateProcess(client->hProcess, 0);
}

Referenced by ReadFromPipeThread(), and WriteToPipeThread().

UserLogin()

static void UserLogin ( int  client_socket )

static

Definition at line 138 of file telnetd.c.

{
  HANDLE     threadHandle;
  client_t  *client = malloc(sizeof(client_t));
 
  if (client == NULL)
    ErrorExit("failed to allocate memory for client");
 
  client->socket = client_socket;
  threadHandle = CreateThread(NULL, 0, UserLoginThread, client, 0, NULL);
  if (threadHandle == NULL)
    free(client);
  else
    CloseHandle(threadHandle);
}

Referenced by WaitForConnect().

UserLoginThread()

static DWORD WINAPI UserLoginThread ( LPVOID  data )

static

Definition at line 155 of file telnetd.c.

{
  client_t  *client = (client_t *) data;
  char       welcome[256];
  char       hostname[64] = "Unknown";
  char      *pwdPrompt = "\r\npass:";
  //char      *logonPrompt = "\r\nLogin OK, please wait...";
  //char      *byebye = "\r\nWrong! bye bye...\r\n";
  char       userID[USERID_SIZE];
  char       password[USERID_SIZE];
  int        received;
  char      *terminator;
 
  if (DoTelnetHandshake(client->socket)) {
    closesocket(client->socket);
    free(client);
    return 0;
  }
 
  gethostname(hostname, sizeof(hostname));
  sprintf(welcome, "\r\nWelcome to %s, please identify yourself\r\n\r\nuser:", hostname);
 
  if (send(client->socket, welcome, strlen(welcome), 0) < 0) {   
    closesocket(client->socket);
    free(client);
    return 0;
  }
  received = ReceiveLine(client->socket, userID, sizeof(userID), Echo );
  if (received < 0) {
    closesocket(client->socket);
    free(client);
    return 0;
  } else if (received) {
    if ((terminator = strchr(userID, CR)) != NULL) {
      *terminator = '\0';
    }
  }
 
  if (send(client->socket, pwdPrompt, strlen(pwdPrompt), 0) < 0) {   
    closesocket(client->socket);
    free(client);
    return 0;
  }
  received = ReceiveLine(client->socket, password, sizeof(password), Password );
 
#if 0
  if (received < 0) {
    closesocket(client->socket);
    free(client);
    return 0;
  } else if (received) {
    if ((terminator = strchr(password, CR)) != NULL) {
      *terminator = '\0';
    }
  }
#endif
 
  /* TODO: do authentication here */
 
  
  telnetd_printf("User '%p' logged on\n", userID);
#if 0
  strcpy(client->userID, userID);
  if (send(client->socket, logonPrompt, strlen(logonPrompt), 0) < 0) {   
    closesocket(client->socket);
    free(client);
    return 0;
  }
#endif
  RunShell(client);
  return 0;
}

Referenced by UserLogin().

WaitForConnect()

static void WaitForConnect ( void  )

static

Definition at line 120 of file telnetd.c.

{
  struct sockaddr_in sa;
  int new_sock;
 
  if (listen(sock, 1) < 0)
     ErrorExit("Cannot listen on socket");
 
  if ((new_sock = accept(sock, (struct sockaddr*) &sa, NULL)) < 0) {
    fprintf(stderr, "Failed to accept incoming call\n");
  } else {
    telnetd_printf("user connected on socket %d, port %d, address %lx\n", new_sock,
                                       htons(sa.sin_port), sa.sin_addr.s_addr);
    UserLogin(new_sock);
  }
}

Referenced by kickoff_telnetd().

WriteToPipeThread()

static DWORD WINAPI WriteToPipeThread ( LPVOID  data )

static

Definition at line 503 of file telnetd.c.

{
  int       iRead;
  DWORD     dwWritten;
  CHAR      chBuf[BUFSIZE];
  client_t *client = (client_t *) data;
 
  while (!client->bTerminate) {
    iRead = ReceiveLine(client->socket, chBuf, BUFSIZE, FALSE);
    if (iRead < 0) {
      telnetd_printf("Client disconnect\n");
      break;
    } else if (iRead > 0) {
      if (strchr(chBuf, CTRLC)) {
        GenerateConsoleCtrlEvent(CTRL_C_EVENT, client->dwProcessId);
      }
      if (send(client->socket, chBuf, iRead, 0) < 0) {
         telnetd_printf("error writing to socket\n");
         break;    
      }
      if (! WriteFile(client->hChildStdinWr, chBuf, (DWORD) iRead, &dwWritten, NULL)) {
        telnetd_printf("Error writing to pipe\n");
        break;
      }
    }
  }
 
  if (!client->bTerminate)
    TerminateShell(client);
 
  telnetd_printf("WriteToPipeThread terminated\n");
 
  client->bWriteToPipe = FALSE;
  return 0;
}

Referenced by RunShell().

Variable Documentation

bShutdown

BOOLEAN bShutdown = 0

static

Definition at line 36 of file telnetd.c.

Referenced by kickoff_telnetd().

bSocketInterfaceInitialised

BOOLEAN bSocketInterfaceInitialised = 0

static

Definition at line 37 of file telnetd.c.

Referenced by Cleanup(), ErrorExit(), and StartSocketInterface().

sock

int sock

static

Definition at line 38 of file telnetd.c.