- Use the Wine spooler service as the service entry template as I was
[reactos.git] / rosapps / applications / sysutils / telnetd / telnetd.c
1 /*
2 * Abstract: a simple telnet 'daemon' for Windows hosts.
3 *
4 * Compiled & run successfully using MSVC 5.0 under Windows95 (requires
5 * Winsock2 update) and Windows98 and MSVC 6.0 under WindowsNT4
6 *
7 * Compiler options : no special options needed
8 * Linker options : add wsock32.lib or ws2_32.lib
9 *
10 * Written by fred.van.lieshout 'at' zonnet.nl
11 * Use freely, no copyrights.
12 * Use Linux.
13 *
14 * TODO:
15 * - access control
16 * - will/won't handshake
17 * - Unify Debugging output and return StatusCodes
18 */
19
20 #include <stdio.h>
21 #include <windows.h>
22
23 #include "telnetd.h"
24
25 /* Local data */
26
27 static BOOLEAN bShutdown = 0;
28 static BOOLEAN bSocketInterfaceInitialised = 0;
29
30 static int sock;
31
32 /* In the future, some options might be passed here to handle
33 * authentication options in the registry or command line
34 * options passed to the service
35 *
36 * Once you are ready to turn on the service
37 * rename this function
38 * int kickoff_telnetd(void)
39 */
40 int main(int argc, char **argv)
41 {
42 SetConsoleCtrlHandler(Cleanup, 1);
43
44 if (!StartSocketInterface()) {
45 ErrorExit("Unable to start socket interface\n");
46 }
47
48 CreateSocket();
49
50 while(!bShutdown) {
51 WaitForConnect();
52 }
53
54 WSACleanup();
55 return 0;
56 }
57
58 /* Cleanup */
59 static BOOL WINAPI Cleanup(DWORD dwControlType)
60 {
61 if (bSocketInterfaceInitialised) {
62 printf("Cleanup...\n");
63 WSACleanup();
64 }
65 return 0;
66 }
67
68 /* StartSocketInterface */
69 static BOOLEAN StartSocketInterface(void)
70 {
71 WORD wVersionRequested;
72 WSADATA wsaData;
73 int err;
74
75 wVersionRequested = MAKEWORD( 2, 0 );
76 err = WSAStartup(wVersionRequested, &wsaData);
77 if (err != 0) {
78 printf("requested winsock version not supported\n");
79 return 0;
80 }
81
82 bSocketInterfaceInitialised = 1; /* for ErrorExit function */
83
84 if ( wsaData.wVersion != wVersionRequested) {
85 printf("requested winsock version not supported\n");
86 return 0;
87 }
88 printf("TelnetD, using %s\n", wsaData.szDescription);
89 return 1;
90 }
91
92 /*
93 ** CreateSocket
94 */
95 static void CreateSocket(void)
96 {
97 struct sockaddr_in sa;
98
99 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
100 if (sock < 0) {
101 ErrorExit("Cannot create socket");
102 }
103
104 memset(&sa, 0, sizeof(sa));
105 sa.sin_family = AF_INET;
106 sa.sin_addr.s_addr = INADDR_ANY;
107 sa.sin_port = htons(TELNET_PORT);
108 if (bind(sock, (struct sockaddr*) &sa, sizeof(sa)) != 0) {
109 ErrorExit("Cannot bind address to socket");
110 }
111 }
112
113 /*
114 ** WaitForConnect
115 */
116 static void WaitForConnect(void)
117 {
118 struct sockaddr_in sa;
119 int new_sock;
120
121 if (listen(sock, 1) < 0) {
122 ErrorExit("Cannot listen on socket");
123 }
124
125 if ((new_sock = accept(sock, (struct sockaddr*) &sa, NULL)) < 0) {
126 fprintf(stderr, "Failed to accept incoming call\n");
127 } else {
128 printf("user connected on socket %d, port %d, address %lx\n", new_sock,
129 htons(sa.sin_port), sa.sin_addr.s_addr);
130 UserLogin(new_sock);
131 }
132 }
133
134
135 /*
136 ** Function: UserLogin
137 */
138 static void UserLogin(int client_socket)
139 {
140 DWORD threadID;
141 client_t *client = malloc(sizeof(client_t));
142
143 if (client == NULL) {
144 ErrorExit("failed to allocate memory for client");
145 }
146
147 client->socket = client_socket;
148 CreateThread(NULL, 0, UserLoginThread, client, 0, &threadID);
149 }
150
151 /*
152 ** Function: UserLoginThread
153 */
154 static DWORD WINAPI UserLoginThread(LPVOID data)
155 {
156 client_t *client = (client_t *) data;
157 char welcome[256];
158 char hostname[64] = "Unknown";
159 char *pwdPrompt = "\r\npass:";
160 //char *logonPrompt = "\r\nLogin OK, please wait...";
161 //char *byebye = "\r\nWrong! bye bye...\r\n";
162 char userID[USERID_SIZE];
163 char password[USERID_SIZE];
164 int received;
165 char *terminator;
166
167 if (DoTelnetHandshake(client->socket)) {
168 closesocket(client->socket);
169 free(client);
170 return 0;
171 }
172
173 gethostname(hostname, sizeof(hostname));
174 sprintf(welcome, "\r\nWelcome to %s, please identify yourself\r\n\r\nuser:", hostname);
175
176 if (send(client->socket, welcome, strlen(welcome), 0) < 0) {
177 closesocket(client->socket);
178 free(client);
179 return 0;
180 }
181 received = ReceiveLine(client->socket, userID, sizeof(userID), Echo );
182 if (received < 0) {
183 closesocket(client->socket);
184 free(client);
185 return 0;
186 } else if (received) {
187 if ((terminator = strchr(userID, CR)) != NULL) {
188 *terminator = '\0';
189 }
190 }
191
192 if (send(client->socket, pwdPrompt, strlen(pwdPrompt), 0) < 0) {
193 closesocket(client->socket);
194 free(client);
195 return 0;
196 }
197 received = ReceiveLine(client->socket, password, sizeof(password), Password );
198
199 #if 0
200 if (received < 0) {
201 closesocket(client->socket);
202 free(client);
203 return 0;
204 } else if (received) {
205 if ((terminator = strchr(password, CR)) != NULL) {
206 *terminator = '\0';
207 }
208 }
209 #endif
210
211 /* TODO: do authentication here */
212
213
214 printf("User '%s' logged on\n", userID);
215 #if 0
216 strcpy(client->userID, userID);
217 if (send(client->socket, logonPrompt, strlen(logonPrompt), 0) < 0) {
218 closesocket(client->socket);
219 free(client);
220 return 0;
221 }
222 #endif
223 RunShell(client);
224 return 0;
225 }
226
227 /*
228 ** Function: DoTelnetHandshake
229 */
230 static int DoTelnetHandshake(int sock)
231 {
232 int retval;
233 int received;
234 fd_set set;
235 struct timeval timeout = { HANDSHAKE_TIMEOUT, 0 };
236
237 char will_echo[]=
238 IAC DONT ECHO
239 IAC WILL ECHO
240 IAC WILL NAWS
241 IAC WILL SUPPRESS_GO_AHEAD
242 IAC DO SUPPRESS_GO_AHEAD
243 IAC DONT NEWENVIRON
244 IAC WONT NEWENVIRON
245 IAC WONT LINEMODE
246 IAC DO NAWS
247 IAC SB TERMINAL_TYPE "\x01" IAC SE
248 ;
249
250 unsigned char client_reply[256];
251
252 if (send(sock, will_echo, sizeof(will_echo), 0) < 0) {
253 return -1;
254 }
255
256 /* Now wait for client response (and ignore it) */
257 FD_ZERO(&set);
258 FD_SET(sock, &set);
259
260 do {
261 retval = select(0, &set, NULL, NULL, &timeout);
262 /* check for error */
263 if (retval < 0) {
264 return -1;
265 /* check for timeout */
266 } else if (retval == 0) {
267 return 0;
268 }
269 /* no error and no timeout, we have data in our sock */
270 received = recv(sock, (char *) client_reply, sizeof(client_reply), 0);
271 if (received <= 0) {
272 return -1;
273 }
274 } while (retval);
275
276 return 0;
277 }
278
279 /*
280 ** Function: ReceiveLine
281 **
282 ** Abstract: receive until timeout or CR
283 ** In : sock, len
284 ** Out : buffer
285 ** Result : int
286 ** Pre : 'sock' must be valid socket
287 ** Post : (result = the number of bytes read into 'buffer')
288 ** OR (result = -1 and error)
289 */
290 static int ReceiveLine(int sock, char *buffer, int len, EchoMode echo)
291 {
292 int i = 0;
293 int retval;
294 fd_set set;
295 struct timeval timeout = { 0, 100000 };
296 char del[3] = { BS, ' ', BS };
297 char asterisk[1] = { '*' };
298
299 FD_ZERO(&set);
300 FD_SET(sock, &set);
301
302 memset(buffer, '\0', len);
303
304 do {
305 /* When we're in echo mode, we do not need a timeout */
306 retval = select(0, &set, NULL, NULL, (echo ? NULL : &timeout) );
307 /* check for error */
308 if (retval < 0) {
309 return -1;
310 /* check for timeout */
311 } else if (retval == 0) {
312 /* return number of characters received so far */
313 return i;
314 }
315 /* no error and no timeout, we have data in our sock */
316 if (recv(sock, &buffer[i], 1, 0) <= 0) {
317 return -1;
318 }
319 if ((buffer[i] == '\0') || (buffer[i] == LF)) {
320 /* ignore null characters and linefeeds from DOS telnet clients */
321 buffer[i] = '\0';
322 } else if ((buffer[i] == DEL) || (buffer[i] == BS)) {
323 /* handle delete and backspace */
324 buffer[i] = '\0';
325 if (echo) {
326 if (i > 0) {
327 i--;
328 buffer[i] = '\0';
329 if (send(sock, del, sizeof(del), 0) < 0) {
330 return -1;
331 }
332 }
333 } else {
334 buffer[i] = BS; /* Let shell process handle it */
335 i++;
336 }
337 } else {
338 /* echo typed characters */
339 if (echo == Echo && send(sock, &buffer[i], 1, 0) < 0) {
340 return -1;
341 } else if (echo == Password && send(sock, asterisk, sizeof(asterisk), 0) < 0) {
342 return -1;
343 }
344 if (buffer[i] == CR) {
345 i++;
346 buffer[i] = LF; /* append LF for DOS command processor */
347 i++;
348 return i;
349 }
350
351 i++;
352 }
353 } while (i < len);
354
355 return i;
356 }
357
358 /*
359 ** Function: RunShell
360 */
361 static void RunShell(client_t *client)
362 {
363 DWORD threadID;
364 HANDLE hChildStdinRd;
365 HANDLE hChildStdinWr;
366 HANDLE hChildStdoutRd;
367 HANDLE hChildStdoutWr;
368 STARTUPINFO si;
369 PROCESS_INFORMATION piProcInfo;
370 SECURITY_ATTRIBUTES saAttr;
371
372 const char *name = "c:\\windows\\system32\\cmd.exe";
373 const char *cmd = NULL;
374 //const char *name = "d:\\cygwin\\bin\\bash.exe";
375 //const char *cmd = "d:\\cygwin\\bin\\bash.exe --login -i";
376
377 saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
378 saAttr.bInheritHandle = TRUE;
379 saAttr.lpSecurityDescriptor = NULL;
380
381 // Create a pipe for the child process's STDOUT.
382 if (! CreatePipe(&hChildStdoutRd, &hChildStdoutWr, &saAttr, 0))
383 ErrorExit("Stdout pipe creation failed\n");
384
385 if (! CreatePipe(&hChildStdinRd, &hChildStdinWr, &saAttr, 0))
386 ErrorExit("Stdin pipe creation failed\n");
387
388
389 client->bTerminate = FALSE;
390 client->bWriteToPipe = TRUE;
391 client->bReadFromPipe = TRUE;
392 client->hChildStdinWr = hChildStdinWr;
393 client->hChildStdoutRd = hChildStdoutRd;
394
395
396 // Create the child process (the shell)
397 printf("Creating child process...\n");
398
399 ZeroMemory( &si, sizeof(STARTUPINFO) );
400 si.cb = sizeof(STARTUPINFO);
401
402 si.dwFlags = STARTF_USESTDHANDLES;
403 si.hStdInput = hChildStdinRd;
404 si.hStdOutput = hChildStdoutWr;
405 si.hStdError = hChildStdoutWr;
406
407 //si.dwFlags |= STARTF_USESHOWWINDOW;
408 //si.wShowWindow = SW_SHOW;
409
410 if (!CreateProcess((LPSTR) name, // executable module
411 (LPSTR) cmd, // command line
412 NULL, // process security attributes
413 NULL, // primary thread security attributes
414 TRUE, // handles are inherited
415 DETACHED_PROCESS + // creation flags
416 CREATE_NEW_PROCESS_GROUP,
417 NULL, // use parent's environment
418 NULL, // use parent's current directory
419 &si, // startup info
420 &piProcInfo)) {
421 ErrorExit("Create process failed");
422 }
423
424 client->hProcess = piProcInfo.hProcess;
425 client->dwProcessId = piProcInfo.dwProcessId;
426
427 printf("New child created (groupid=%lu)\n", client->dwProcessId);
428
429 // No longer need these in the parent...
430 if (!CloseHandle(hChildStdoutWr))
431 ErrorExit("Closing handle failed");
432 if (!CloseHandle(hChildStdinRd))
433 ErrorExit("Closing handle failed");
434
435 CreateThread(NULL, 0, WriteToPipeThread, client, 0, &threadID);
436 CreateThread(NULL, 0, ReadFromPipeThread, client, 0, &threadID);
437 CreateThread(NULL, 0, MonitorChildThread, client, 0, &threadID);
438 }
439
440
441 /*
442 ** Function: MonitorChildThread
443 **
444 ** Abstract: Monitor the child (shell) process
445 */
446 static DWORD WINAPI MonitorChildThread(LPVOID data)
447 {
448 DWORD exitCode;
449 client_t *client = (client_t *) data;
450
451 printf("Monitor thread running...\n");
452
453 WaitForSingleObject(client->hProcess, INFINITE);
454
455 GetExitCodeProcess(client->hProcess, &exitCode);
456 printf("Child process terminated with code %lx\n", exitCode);
457
458 /* signal the other threads to give up */
459 client->bTerminate = TRUE;
460
461 Sleep(500);
462
463 CloseHandle(client->hChildStdoutRd);
464 CloseHandle(client->hChildStdinWr);
465 CloseHandle(client->hProcess);
466
467 closesocket(client->socket);
468
469 printf("Waiting for all threads to give up..\n");
470
471 while (client->bWriteToPipe || client->bReadFromPipe) {
472 printf(".");
473 fflush(stdout);
474 Sleep(1000);
475 }
476
477 printf("Cleanup for user '%s'\n", client->userID);
478 free(client);
479 return 0;
480 }
481
482 /*
483 ** Function: WriteToPipeThread
484 **
485 ** Abstract: read data from the telnet client socket
486 ** and pass it on to the shell process.
487 */
488 static DWORD WINAPI WriteToPipeThread(LPVOID data)
489 {
490 int iRead;
491 DWORD dwWritten;
492 CHAR chBuf[BUFSIZE];
493 client_t *client = (client_t *) data;
494
495 while (!client->bTerminate) {
496 iRead = ReceiveLine(client->socket, chBuf, BUFSIZE, FALSE);
497 if (iRead < 0) {
498 printf("Client disconnect\n");
499 break;
500 } else if (iRead > 0) {
501 if (strchr(chBuf, CTRLC)) {
502 GenerateConsoleCtrlEvent(CTRL_C_EVENT, client->dwProcessId);
503 }
504 if (send(client->socket, chBuf, iRead, 0) < 0) {
505 printf("error writing to socket\n");
506 break;
507 }
508 if (! WriteFile(client->hChildStdinWr, chBuf, (DWORD) iRead, &dwWritten, NULL)) {
509 printf("Error writing to pipe\n");
510 break;
511 }
512 }
513 }
514
515 if (!client->bTerminate) {
516 TerminateShell(client);
517 }
518
519 printf("WriteToPipeThread terminated\n");
520
521 client->bWriteToPipe = FALSE;
522 return 0;
523 }
524
525 /*
526 ** Function: ReadFromPipeThread
527 **
528 ** Abstract: Read data from the shell's stdout handle and
529 ** pass it on to the telnet client socket.
530 */
531 static DWORD WINAPI ReadFromPipeThread(LPVOID data)
532 {
533 DWORD dwRead;
534 DWORD dwAvail;
535 CHAR chBuf[BUFSIZE];
536 CHAR txBuf[BUFSIZE*2];
537 DWORD from,to;
538 //char warning[] = "warning: rl_prep_terminal: cannot get terminal settings";
539
540 client_t *client = (client_t *) data;
541
542 while (!client->bTerminate && client->bWriteToPipe) {
543 // Since we do not want to block, first peek...
544 if (PeekNamedPipe(client->hChildStdoutRd, NULL, 0, NULL, &dwAvail, NULL) == 0) {
545 printf("Failed to peek in pipe\n");
546 break;
547 }
548 if (dwAvail) {
549 if( ! ReadFile( client->hChildStdoutRd, chBuf, BUFSIZE, &dwRead, NULL) ||
550 dwRead == 0) {
551 printf("Failed to read from pipe\n");
552 break;
553 }
554 for (from=0, to=0; from<dwRead; from++, to++) {
555 txBuf[to] = chBuf[from];
556 if (txBuf[to] == '\n') {
557 txBuf[to] = '\r';
558 to++;
559 txBuf[to] = '\n';
560 }
561 }
562 if (send(client->socket, txBuf, to, 0) < 0) {
563 printf("error writing to socket\n");
564 break;
565 }
566 }
567 Sleep(100); /* Hmmm, oh well... what the heck! */
568 }
569
570 if (!client->bTerminate) {
571 TerminateShell(client);
572 }
573
574 printf("ReadFromPipeThread terminated\n");
575
576 client->bReadFromPipe = FALSE;
577 return 0;
578 }
579
580 /*
581 ** TerminateShell
582 */
583 static void TerminateShell(client_t *client)
584 {
585 DWORD exitCode;
586 DWORD dwWritten;
587 char stop[] = "\003\r\nexit\r\n"; /* Ctrl-C + exit */
588
589 GetExitCodeProcess(client->hProcess, &exitCode);
590 if (exitCode == STILL_ACTIVE) {
591 printf("user shell still active, send Ctrl-Break to group-id %lu\n", client->dwProcessId );
592
593 if (!GenerateConsoleCtrlEvent( CTRL_BREAK_EVENT, client->dwProcessId )) {
594 printf("Failed to send Ctrl_break\n");
595 }
596
597 Sleep(500);
598
599 if (!GenerateConsoleCtrlEvent( CTRL_C_EVENT, client->dwProcessId )) {
600 printf("Failed to send Ctrl_C\n");
601 }
602
603 Sleep(500);
604
605 if (! WriteFile(client->hChildStdinWr, stop, sizeof(stop), &dwWritten, NULL)) {
606 printf("Error writing to pipe\n");
607 }
608
609 Sleep(500);
610
611 GetExitCodeProcess(client->hProcess, &exitCode);
612 if (exitCode == STILL_ACTIVE) {
613 printf("user shell still active, attempt to terminate it now...\n");
614 TerminateProcess(client->hProcess, 0);
615 }
616 }
617 }
618
619 /*
620 ** ErrorExit
621 */
622 static VOID ErrorExit (LPTSTR lpszMessage)
623 {
624 fprintf(stderr, "%s\n", lpszMessage);
625 if (bSocketInterfaceInitialised) {
626 printf("WSAGetLastError=%d\n", WSAGetLastError());
627 WSACleanup();
628 }
629 ExitProcess(0);
630 }
631