repos/CCSFinger/CCSFinger.cpp

// Douglas Thrift
//
// CCS Computer Science
//
// Windows Finger Daemon

#include <windows.h>
#include <tchar.h>
#include <signal.h>
#include <wtsapi32.h>

#include <iostream>
#include <string>

LPTSTR name;
SERVICE_STATUS status;
SERVICE_STATUS_HANDLE handle;
HANDLE stop;
WSADATA data;

void FingerDaemon();
void FingerStop(int);
void WINAPI FingerMain(DWORD argc, LPTSTR *argv);
void WINAPI FingerControl(DWORD control);

int _tmain(int argc, TCHAR *argv[])
{
        PWTS_SESSION_INFO sessions;
        DWORD count;

        if (!WTSEnumerateSessions(WTS_CURRENT_SERVER_HANDLE, 0, 1, &sessions, &count))
        {
                std::cerr << GetLastError() << std::endl;

                return 1;
        }

        for (PWTS_SESSION_INFO session = sessions; session != sessions + count; ++session)
        {
                LPTSTR userName, clientName;
                DWORD userNameSize, clientNameSize;

                WTSQuerySessionInformation(WTS_CURRENT_SERVER_HANDLE, session->SessionId, WTSUserName, &userName, &userNameSize);
                WTSQuerySessionInformation(WTS_CURRENT_SERVER_HANDLE, session->SessionId, WTSClientName, &clientName, &clientNameSize);

                std::wcout << '{' << std::endl
                        << '\t' << session->SessionId << std::endl
                        << '\t' << session->pWinStationName << std::endl
                        << '\t';

                switch (session->State)
                {
                case WTSActive:
                        std::cout << "Active";
                        
                        break;
                case WTSConnected:
                        std::cout << "Connected";

                        break;
                case WTSConnectQuery:
                        std::cout << "Connect Query";

                        break;
                case WTSShadow:
                        std::cout << "Shadow";

                        break;
                case WTSDisconnected:
                        std::cout << "Disconnected";

                        break;
                case WTSIdle:
                        std::cout << "Idle";

                        break;
                case WTSListen:
                        std::cout << "Listen";

                        break;
                case WTSReset:
                        std::cout << "Reset";

                        break;
                case WTSDown:
                        std::cout << "Down";

                        break;
                case WTSInit:
                        std::cout << "Init";

                        break;
                }

                std::wcout << std::endl << '\t' << userName << std::endl
                        << '\t' << clientName << std::endl
                        << '}' << std::endl;

                WTSFreeMemory(userName);
                WTSFreeMemory(clientName);
        }

        WTSFreeMemory(sessions);

        /*SERVICE_TABLE_ENTRY entry[] = { { TEXT("CCS Finger Daemon"), LPSERVICE_MAIN_FUNCTION(FingerMain) }, { NULL, NULL } };

        if (!StartServiceCtrlDispatcher(entry))
        {
                DWORD error(GetLastError());

                switch (error)
                {
                case ERROR_FAILED_SERVICE_CONTROLLER_CONNECT:
                        goto go;

                case ERROR_INVALID_DATA:
                        std::cerr << "ERROR_INVALID_DATA" << std::endl;

                        break;

                case ERROR_SERVICE_ALREADY_RUNNING:
                        std::cerr << "ERROR_SERVICE_ALREADY_RUNNING" << std::endl;

                        break;

                default:
                        std::cerr << error << std::endl;
                }

                return 1;
        }

        return 0;

go:
        stop = CreateEvent(NULL, TRUE, FALSE, NULL);

        signal(SIGINT, FingerStop);

        try
        {
                FingerDaemon();
        }
        catch (...) {}

        return 0;*/
}

void FingerDaemon()
{
        WSAStartup(MAKEWORD(2, 0), &data);

        //

        SOCKET server(socket(PF_INET, SOCK_STREAM, IPPROTO_TCP));
        SOCKADDR_IN service;
        
        service.sin_family = AF_INET;
        service.sin_addr.s_addr = inet_addr("0.0.0.0");
        service.sin_port = htons(79);

        bind(server, (SOCKADDR *)(&service), sizeof (service));
        listen(server, SOMAXCONN);

        SOCKET client;

        while(WaitForSingleObject(stop, 1000) != WAIT_OBJECT_0 && (client = accept(server, NULL, NULL)) == SOCKET_ERROR)
        {
                //
        }

        //

        closesocket(server);

        WSACleanup();
}

void FingerStop(int)
{
        SetEvent(stop);

        std::cout << "Stop!" << std::endl;
}

void WINAPI FingerMain(DWORD argc, LPTSTR *argv)
{
        name = argv[0];
        handle = RegisterServiceCtrlHandler(name, LPHANDLER_FUNCTION(FingerControl));
        stop = CreateEvent(NULL, TRUE, FALSE, NULL);

        //

        status.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
        status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
        status.dwServiceSpecificExitCode = 0;
        status.dwCurrentState = SERVICE_RUNNING;
        status.dwWin32ExitCode = NO_ERROR;
        status.dwCheckPoint = 0;
        status.dwWaitHint = 0;

        SetServiceStatus(handle, &status);

        try
        {
                FingerDaemon();
        }
        catch (...) {}

        status.dwCurrentState = SERVICE_STOPPED;
        status.dwWin32ExitCode = NO_ERROR;
        status.dwCheckPoint = 0;
        status.dwWaitHint = 0;

        SetServiceStatus(handle, &status);
}

void WINAPI FingerControl(DWORD control)
{
        switch (control)
        {
        case SERVICE_CONTROL_STOP:
        case SERVICE_CONTROL_SHUTDOWN:
                status.dwCurrentState = SERVICE_STOP_PENDING;

                SetEvent(stop);

                break;

        case SERVICE_CONTROL_INTERROGATE:
                break;
        }

        SetServiceStatus(handle, &status);
}
Revision:	608
Committed:	2005-11-30T18:23:39-08:00 (19 years, 6 months ago) by douglas
File size:	4593 byte(s)
Log Message:	Hmm, getting somewhere it would seem.
#	User	Rev	Content
1	douglas	594	// Douglas Thrift
2			//
3			// CCS Computer Science
4			//
5			// Windows Finger Daemon
6
7			#include <windows.h>
8			#include <tchar.h>
9	douglas	596	#include <signal.h>
10	douglas	608	#include <wtsapi32.h>
11	douglas	594
12	douglas	595	#include <iostream>
13	douglas	608	#include <string>
14	douglas	595
15			LPTSTR name;
16	douglas	594	SERVICE_STATUS status;
17			SERVICE_STATUS_HANDLE handle;
18	douglas	595	HANDLE stop;
19	douglas	594	WSADATA data;
20
21	douglas	596	void FingerDaemon();
22			void FingerStop(int);
23	douglas	595	void WINAPI FingerMain(DWORD argc, LPTSTR *argv);
24			void WINAPI FingerControl(DWORD control);
25	douglas	594
26			int _tmain(int argc, TCHAR *argv[])
27			{
28	douglas	608	PWTS_SESSION_INFO sessions;
29			DWORD count;
30	douglas	594
31	douglas	608	if (!WTSEnumerateSessions(WTS_CURRENT_SERVER_HANDLE, 0, 1, &sessions, &count))
32			{
33			std::cerr << GetLastError() << std::endl;
34
35			return 1;
36			}
37
38			for (PWTS_SESSION_INFO session = sessions; session != sessions + count; ++session)
39			{
40			LPTSTR userName, clientName;
41			DWORD userNameSize, clientNameSize;
42
43			WTSQuerySessionInformation(WTS_CURRENT_SERVER_HANDLE, session->SessionId, WTSUserName, &userName, &userNameSize);
44			WTSQuerySessionInformation(WTS_CURRENT_SERVER_HANDLE, session->SessionId, WTSClientName, &clientName, &clientNameSize);
45
46			std::wcout << '{' << std::endl
47			<< '\t' << session->SessionId << std::endl
48			<< '\t' << session->pWinStationName << std::endl
49			<< '\t';
50
51			switch (session->State)
52			{
53			case WTSActive:
54			std::cout << "Active";
55
56			break;
57			case WTSConnected:
58			std::cout << "Connected";
59
60			break;
61			case WTSConnectQuery:
62			std::cout << "Connect Query";
63
64			break;
65			case WTSShadow:
66			std::cout << "Shadow";
67
68			break;
69			case WTSDisconnected:
70			std::cout << "Disconnected";
71
72			break;
73			case WTSIdle:
74			std::cout << "Idle";
75
76			break;
77			case WTSListen:
78			std::cout << "Listen";
79
80			break;
81			case WTSReset:
82			std::cout << "Reset";
83
84			break;
85			case WTSDown:
86			std::cout << "Down";
87
88			break;
89			case WTSInit:
90			std::cout << "Init";
91
92			break;
93			}
94
95			std::wcout << std::endl << '\t' << userName << std::endl
96			<< '\t' << clientName << std::endl
97			<< '}' << std::endl;
98
99			WTSFreeMemory(userName);
100			WTSFreeMemory(clientName);
101			}
102
103			WTSFreeMemory(sessions);
104
105			/*SERVICE_TABLE_ENTRY entry[] = { { TEXT("CCS Finger Daemon"), LPSERVICE_MAIN_FUNCTION(FingerMain) }, { NULL, NULL } };
106
107	douglas	594	if (!StartServiceCtrlDispatcher(entry))
108			{
109			DWORD error(GetLastError());
110
111			switch (error)
112			{
113			case ERROR_FAILED_SERVICE_CONTROLLER_CONNECT:
114	douglas	595	goto go;
115	douglas	594
116			case ERROR_INVALID_DATA:
117			std::cerr << "ERROR_INVALID_DATA" << std::endl;
118
119			break;
120
121			case ERROR_SERVICE_ALREADY_RUNNING:
122			std::cerr << "ERROR_SERVICE_ALREADY_RUNNING" << std::endl;
123
124			break;
125
126			default:
127			std::cerr << error << std::endl;
128			}
129
130			return 1;
131			}
132
133			return 0;
134	douglas	595
135			go:
136	douglas	608	stop = CreateEvent(NULL, TRUE, FALSE, NULL);
137
138	douglas	596	signal(SIGINT, FingerStop);
139	douglas	595
140	douglas	596	try
141			{
142			FingerDaemon();
143			}
144			catch (...) {}
145
146	douglas	608	return 0;*/
147	douglas	594	}
148
149	douglas	596	void FingerDaemon()
150	douglas	594	{
151			WSAStartup(MAKEWORD(2, 0), &data);
152
153			//
154
155	douglas	608	SOCKET server(socket(PF_INET, SOCK_STREAM, IPPROTO_TCP));
156	douglas	594	SOCKADDR_IN service;
157
158			service.sin_family = AF_INET;
159			service.sin_addr.s_addr = inet_addr("0.0.0.0");
160			service.sin_port = htons(79);
161
162	douglas	608	bind(server, (SOCKADDR *)(&service), sizeof (service));
163			listen(server, SOMAXCONN);
164	douglas	594
165	douglas	608	SOCKET client;
166
167			while(WaitForSingleObject(stop, 1000) != WAIT_OBJECT_0 && (client = accept(server, NULL, NULL)) == SOCKET_ERROR)
168	douglas	594	{
169			//
170			}
171
172			//
173
174	douglas	608	closesocket(server);
175
176	douglas	594	WSACleanup();
177	douglas	596	}
178	douglas	594
179	douglas	596	void FingerStop(int)
180			{
181			SetEvent(stop);
182
183			std::cout << "Stop!" << std::endl;
184			}
185
186			void WINAPI FingerMain(DWORD argc, LPTSTR *argv)
187			{
188			name = argv[0];
189			handle = RegisterServiceCtrlHandler(name, LPHANDLER_FUNCTION(FingerControl));
190			stop = CreateEvent(NULL, TRUE, FALSE, NULL);
191
192			//
193
194			status.dwControlsAccepted = SERVICE_ACCEPT_STOP \| SERVICE_ACCEPT_SHUTDOWN;
195			status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
196			status.dwServiceSpecificExitCode = 0;
197			status.dwCurrentState = SERVICE_RUNNING;
198			status.dwWin32ExitCode = NO_ERROR;
199			status.dwCheckPoint = 0;
200			status.dwWaitHint = 0;
201
202			SetServiceStatus(handle, &status);
203
204			try
205			{
206			FingerDaemon();
207			}
208			catch (...) {}
209
210	douglas	595	status.dwCurrentState = SERVICE_STOPPED;
211	douglas	594	status.dwWin32ExitCode = NO_ERROR;
212			status.dwCheckPoint = 0;
213			status.dwWaitHint = 0;
214
215			SetServiceStatus(handle, &status);
216			}
217
218			void WINAPI FingerControl(DWORD control)
219			{
220			switch (control)
221			{
222			case SERVICE_CONTROL_STOP:
223			case SERVICE_CONTROL_SHUTDOWN:
224			status.dwCurrentState = SERVICE_STOP_PENDING;
225
226			SetEvent(stop);
227
228			break;
229
230			case SERVICE_CONTROL_INTERROGATE:
231			break;
232			}
233
234	douglas	595	SetServiceStatus(handle, &status);
235	douglas	594	}