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.
#	Content
1	// Douglas Thrift
2	//
3	// CCS Computer Science
4	//
5	// Windows Finger Daemon
6
7	#include <windows.h>
8	#include <tchar.h>
9	#include <signal.h>
10	#include <wtsapi32.h>
11
12	#include <iostream>
13	#include <string>
14
15	LPTSTR name;
16	SERVICE_STATUS status;
17	SERVICE_STATUS_HANDLE handle;
18	HANDLE stop;
19	WSADATA data;
20
21	void FingerDaemon();
22	void FingerStop(int);
23	void WINAPI FingerMain(DWORD argc, LPTSTR *argv);
24	void WINAPI FingerControl(DWORD control);
25
26	int _tmain(int argc, TCHAR *argv[])
27	{
28	PWTS_SESSION_INFO sessions;
29	DWORD count;
30
31	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	if (!StartServiceCtrlDispatcher(entry))
108	{
109	DWORD error(GetLastError());
110
111	switch (error)
112	{
113	case ERROR_FAILED_SERVICE_CONTROLLER_CONNECT:
114	goto go;
115
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
135	go:
136	stop = CreateEvent(NULL, TRUE, FALSE, NULL);
137
138	signal(SIGINT, FingerStop);
139
140	try
141	{
142	FingerDaemon();
143	}
144	catch (...) {}
145
146	return 0;*/
147	}
148
149	void FingerDaemon()
150	{
151	WSAStartup(MAKEWORD(2, 0), &data);
152
153	//
154
155	SOCKET server(socket(PF_INET, SOCK_STREAM, IPPROTO_TCP));
156	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	bind(server, (SOCKADDR *)(&service), sizeof (service));
163	listen(server, SOMAXCONN);
164
165	SOCKET client;
166
167	while(WaitForSingleObject(stop, 1000) != WAIT_OBJECT_0 && (client = accept(server, NULL, NULL)) == SOCKET_ERROR)
168	{
169	//
170	}
171
172	//
173
174	closesocket(server);
175
176	WSACleanup();
177	}
178
179	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	status.dwCurrentState = SERVICE_STOPPED;
211	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	SetServiceStatus(handle, &status);
235	}