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 <lm.h>

#include <iostream>
#include <iomanip>
#include <string>
#include <sstream>
#include <vector>
#include <set>

std::ostream &operator<<(std::ostream &out, WTS_CONNECTSTATE_CLASS status)
{
        switch (status)
        {
        case WTSActive:
                return out << "Active";

        case WTSConnected:
                return out << "Connected";

        case WTSConnectQuery:
                return out << "Connecting";

        case WTSShadow:
                return out << "Shadowing";

        case WTSDisconnected:
                return out << "Disconnected";

        case WTSIdle:
                return out << "Idle";

        case WTSListen:
                return out << "Listening";

        case WTSReset:
                return out << "Reseting";

        case WTSDown:
                return out << "Down";

        case WTSInit:
                return out << "Initializing";

        default:
                return out << "Unknown";
        }
}

inline std::string Utf8(const std::wstring &wstring)
{
        std::string string(::WideCharToMultiByte(CP_UTF8, 0, wstring.data(), int(wstring.size()), NULL, 0, NULL, NULL), '\0');

        ::WideCharToMultiByte(CP_UTF8, 0, wstring.data(), int(wstring.size()), const_cast<LPSTR>(string.data()), int(string.size()), NULL, NULL);

        return string;
}

class Finger
{
private:
        struct Login
        {
                std::string login, name, session;
                DWORD id;
                WTS_CONNECTSTATE_CLASS status;
                Login(const std::wstring &login, DWORD id, const std::wstring &session, WTS_CONNECTSTATE_CLASS status) : login(Utf8(login)), id(id), session(Utf8(session)), status(status)
                {
                        USER_INFO_11 *info;

                        ::NetUserGetInfo(NULL, login.c_str(), 11, reinterpret_cast<LPBYTE *>(&info));

                        name = Utf8(std::wstring(info->usri11_full_name).substr(0, 20));

                        ::NetApiBufferFree(info);
                }

                bool operator<(const Login &login) const
                {
                        if (this->login == login.login)
                                return id < login.id;
                        else
                                return this->login < login.login;
                }
        };
        std::ostringstream stream;
        std::set<Login> logins;

public:
        Finger(bool full)
        {
                PWTS_SESSION_INFO sessions;
                DWORD count;

                ::WTSEnumerateSessions(WTS_CURRENT_SERVER_HANDLE, 0, 1, &sessions, &count);

                for (PWTS_SESSION_INFO session(sessions); session != sessions + count; ++session)
                {
                        LPTSTR name;
                        DWORD size;

                        ::WTSQuerySessionInformation(WTS_CURRENT_SERVER_HANDLE, session->SessionId, WTSUserName, &name, &size);

                        if (!std::wstring(name).empty())
                        {
                                LPTSTR session_;

                                ::WTSQuerySessionInformation(WTS_CURRENT_SERVER_HANDLE, session->SessionId, WTSWinStationName, &session_, &size);

                                Login login(name, session->SessionId, session_, session->State);

                                ::WTSFreeMemory(session_);

                                logins.insert(login);
                        }

                        ::WTSFreeMemory(name);
                }

                ::WTSFreeMemory(sessions);

                if (!full)
                {
                        stream << "Login\t\tName" << std::string(17, ' ') << "Id     Session       Status\r\n";

                        for (std::set<Login>::const_iterator login(logins.begin()); login != logins.end(); ++login)
                                stream << login->login << std::string(16 - login->login.size(), ' ') << login->name << std::string(21 - login->name.size(), ' ') << std::setw(5) << std::left << login->id << "  " << login->session << std::string(14 - login->session.size(), ' ') << login->status << "\r\n";
                }
        }

        Finger(const std::string &name)
        {
                //NetQueryDisplayInformation
                //NetUserGetInfo
        }

        inline operator std::string()
        {
                return stream.str();
        }
};

LPTSTR name;
SERVICE_STATUS status;
SERVICE_STATUS_HANDLE handle;
HANDLE stop;
WSADATA data;
std::vector<HANDLE> threads;

void FingerDaemon();
DWORD WINAPI FingerListen(LPVOID server_);
DWORD WINAPI FingerDo(LPVOID client_);
void FingerStop(int);
void WINAPI FingerMain(DWORD argc, LPTSTR *argv);
void WINAPI FingerControl(DWORD control);

int _tmain(int argc, TCHAR *argv[])
{
        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);

        threads.push_back(::CreateThread(NULL, 0, FingerListen, &server, 0, NULL));

        while(::WaitForSingleObject(stop, 1000) != WAIT_OBJECT_0);

        //

        ::closesocket(server);

        ::WSACleanup();
}

DWORD WINAPI FingerListen(LPVOID server_)
{
        SOCKET &server(*reinterpret_cast<SOCKET *>(server_));

        while (true)
        {
                SOCKET client(accept(server, NULL, NULL));

                threads.push_back(::CreateThread(NULL, 0, FingerDo, &client, 0, NULL));
        }

        return 0;
}

DWORD WINAPI FingerDo(LPVOID client_)
{
        SOCKET &client(*reinterpret_cast<SOCKET *>(client_));
        char buffer[1024];
        std::istringstream stream(std::string(buffer, ::recv(client, buffer, sizeof buffer, 0)));
        std::string line;

        std::getline(stream, line);

        stream.str(line);

        std::getline(stream, line, '\r');

        stream.str(line);

        std::string name;
        bool full(false);

        while (stream >> line)
                if (line == "/W")
                        full = true;
                else
                        name = line;

        std::string finger(name.empty() ? Finger(full) : Finger(name));

        ::send(client, finger.data(), int(finger.size()), 0);
        ::closesocket(client);

        return 0;
}

void FingerStop(int)
{
        ::SetEvent(stop);
}

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:	615
Committed:	2005-12-12T19:26:43-08:00 (19 years, 6 months ago) by douglas
File size:	7284 byte(s)
Log Message:	Moo!
#	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	#include <lm.h>
12
13	#include <iostream>
14	#include <iomanip>
15	#include <string>
16	#include <sstream>
17	#include <vector>
18	#include <set>
19
20	std::ostream &operator<<(std::ostream &out, WTS_CONNECTSTATE_CLASS status)
21	{
22	switch (status)
23	{
24	case WTSActive:
25	return out << "Active";
26
27	case WTSConnected:
28	return out << "Connected";
29
30	case WTSConnectQuery:
31	return out << "Connecting";
32
33	case WTSShadow:
34	return out << "Shadowing";
35
36	case WTSDisconnected:
37	return out << "Disconnected";
38
39	case WTSIdle:
40	return out << "Idle";
41
42	case WTSListen:
43	return out << "Listening";
44
45	case WTSReset:
46	return out << "Reseting";
47
48	case WTSDown:
49	return out << "Down";
50
51	case WTSInit:
52	return out << "Initializing";
53
54	default:
55	return out << "Unknown";
56	}
57	}
58
59	inline std::string Utf8(const std::wstring &wstring)
60	{
61	std::string string(::WideCharToMultiByte(CP_UTF8, 0, wstring.data(), int(wstring.size()), NULL, 0, NULL, NULL), '\0');
62
63	::WideCharToMultiByte(CP_UTF8, 0, wstring.data(), int(wstring.size()), const_cast<LPSTR>(string.data()), int(string.size()), NULL, NULL);
64
65	return string;
66	}
67
68	class Finger
69	{
70	private:
71	struct Login
72	{
73	std::string login, name, session;
74	DWORD id;
75	WTS_CONNECTSTATE_CLASS status;
76	Login(const std::wstring &login, DWORD id, const std::wstring &session, WTS_CONNECTSTATE_CLASS status) : login(Utf8(login)), id(id), session(Utf8(session)), status(status)
77	{
78	USER_INFO_11 *info;
79
80	::NetUserGetInfo(NULL, login.c_str(), 11, reinterpret_cast<LPBYTE *>(&info));
81
82	name = Utf8(std::wstring(info->usri11_full_name).substr(0, 20));
83
84	::NetApiBufferFree(info);
85	}
86
87	bool operator<(const Login &login) const
88	{
89	if (this->login == login.login)
90	return id < login.id;
91	else
92	return this->login < login.login;
93	}
94	};
95	std::ostringstream stream;
96	std::set<Login> logins;
97
98	public:
99	Finger(bool full)
100	{
101	PWTS_SESSION_INFO sessions;
102	DWORD count;
103
104	::WTSEnumerateSessions(WTS_CURRENT_SERVER_HANDLE, 0, 1, &sessions, &count);
105
106	for (PWTS_SESSION_INFO session(sessions); session != sessions + count; ++session)
107	{
108	LPTSTR name;
109	DWORD size;
110
111	::WTSQuerySessionInformation(WTS_CURRENT_SERVER_HANDLE, session->SessionId, WTSUserName, &name, &size);
112
113	if (!std::wstring(name).empty())
114	{
115	LPTSTR session_;
116
117	::WTSQuerySessionInformation(WTS_CURRENT_SERVER_HANDLE, session->SessionId, WTSWinStationName, &session_, &size);
118
119	Login login(name, session->SessionId, session_, session->State);
120
121	::WTSFreeMemory(session_);
122
123	logins.insert(login);
124	}
125
126	::WTSFreeMemory(name);
127	}
128
129	::WTSFreeMemory(sessions);
130
131	if (!full)
132	{
133	stream << "Login\t\tName" << std::string(17, ' ') << "Id Session Status\r\n";
134
135	for (std::set<Login>::const_iterator login(logins.begin()); login != logins.end(); ++login)
136	stream << login->login << std::string(16 - login->login.size(), ' ') << login->name << std::string(21 - login->name.size(), ' ') << std::setw(5) << std::left << login->id << " " << login->session << std::string(14 - login->session.size(), ' ') << login->status << "\r\n";
137	}
138	}
139
140	Finger(const std::string &name)
141	{
142	//NetQueryDisplayInformation
143	//NetUserGetInfo
144	}
145
146	inline operator std::string()
147	{
148	return stream.str();
149	}
150	};
151
152	LPTSTR name;
153	SERVICE_STATUS status;
154	SERVICE_STATUS_HANDLE handle;
155	HANDLE stop;
156	WSADATA data;
157	std::vector<HANDLE> threads;
158
159	void FingerDaemon();
160	DWORD WINAPI FingerListen(LPVOID server_);
161	DWORD WINAPI FingerDo(LPVOID client_);
162	void FingerStop(int);
163	void WINAPI FingerMain(DWORD argc, LPTSTR *argv);
164	void WINAPI FingerControl(DWORD control);
165
166	int _tmain(int argc, TCHAR *argv[])
167	{
168	SERVICE_TABLE_ENTRY entry[] = { { TEXT("CCS Finger Daemon"), LPSERVICE_MAIN_FUNCTION(FingerMain) }, { NULL, NULL } };
169
170	if (!::StartServiceCtrlDispatcher(entry))
171	{
172	DWORD error(::GetLastError());
173
174	switch (error)
175	{
176	case ERROR_FAILED_SERVICE_CONTROLLER_CONNECT:
177	goto go;
178
179	case ERROR_INVALID_DATA:
180	std::cerr << "ERROR_INVALID_DATA" << std::endl;
181
182	break;
183
184	case ERROR_SERVICE_ALREADY_RUNNING:
185	std::cerr << "ERROR_SERVICE_ALREADY_RUNNING" << std::endl;
186
187	break;
188
189	default:
190	std::cerr << error << std::endl;
191	}
192
193	return 1;
194	}
195
196	return 0;
197
198	go:
199	stop = ::CreateEvent(NULL, TRUE, FALSE, NULL);
200
201	::signal(SIGINT, FingerStop);
202
203	try
204	{
205	FingerDaemon();
206	}
207	catch (...) {}
208
209	return 0;
210	}
211
212	void FingerDaemon()
213	{
214	::WSAStartup(MAKEWORD(2, 0), &data);
215
216	//
217
218	SOCKET server(::socket(PF_INET, SOCK_STREAM, IPPROTO_TCP));
219	SOCKADDR_IN service;
220
221	service.sin_family = AF_INET;
222	service.sin_addr.s_addr = inet_addr("0.0.0.0");
223	service.sin_port = htons(79);
224
225	::bind(server, (SOCKADDR *)(&service), sizeof (service));
226	::listen(server, SOMAXCONN);
227
228	threads.push_back(::CreateThread(NULL, 0, FingerListen, &server, 0, NULL));
229
230	while(::WaitForSingleObject(stop, 1000) != WAIT_OBJECT_0);
231
232	//
233
234	::closesocket(server);
235
236	::WSACleanup();
237	}
238
239	DWORD WINAPI FingerListen(LPVOID server_)
240	{
241	SOCKET &server(reinterpret_cast<SOCKET >(server_));
242
243	while (true)
244	{
245	SOCKET client(accept(server, NULL, NULL));
246
247	threads.push_back(::CreateThread(NULL, 0, FingerDo, &client, 0, NULL));
248	}
249
250	return 0;
251	}
252
253	DWORD WINAPI FingerDo(LPVOID client_)
254	{
255	SOCKET &client(reinterpret_cast<SOCKET >(client_));
256	char buffer[1024];
257	std::istringstream stream(std::string(buffer, ::recv(client, buffer, sizeof buffer, 0)));
258	std::string line;
259
260	std::getline(stream, line);
261
262	stream.str(line);
263
264	std::getline(stream, line, '\r');
265
266	stream.str(line);
267
268	std::string name;
269	bool full(false);
270
271	while (stream >> line)
272	if (line == "/W")
273	full = true;
274	else
275	name = line;
276
277	std::string finger(name.empty() ? Finger(full) : Finger(name));
278
279	::send(client, finger.data(), int(finger.size()), 0);
280	::closesocket(client);
281
282	return 0;
283	}
284
285	void FingerStop(int)
286	{
287	::SetEvent(stop);
288	}
289
290	void WINAPI FingerMain(DWORD argc, LPTSTR *argv)
291	{
292	name = argv[0];
293	handle = RegisterServiceCtrlHandler(name, LPHANDLER_FUNCTION(FingerControl));
294	stop = ::CreateEvent(NULL, TRUE, FALSE, NULL);
295
296	//
297
298	status.dwControlsAccepted = SERVICE_ACCEPT_STOP \| SERVICE_ACCEPT_SHUTDOWN;
299	status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
300	status.dwServiceSpecificExitCode = 0;
301	status.dwCurrentState = SERVICE_RUNNING;
302	status.dwWin32ExitCode = NO_ERROR;
303	status.dwCheckPoint = 0;
304	status.dwWaitHint = 0;
305
306	::SetServiceStatus(handle, &status);
307
308	try
309	{
310	FingerDaemon();
311	}
312	catch (...) {}
313
314	status.dwCurrentState = SERVICE_STOPPED;
315	status.dwWin32ExitCode = NO_ERROR;
316	status.dwCheckPoint = 0;
317	status.dwWaitHint = 0;
318
319	::SetServiceStatus(handle, &status);
320	}
321
322	void WINAPI FingerControl(DWORD control)
323	{
324	switch (control)
325	{
326	case SERVICE_CONTROL_STOP:
327	case SERVICE_CONTROL_SHUTDOWN:
328	status.dwCurrentState = SERVICE_STOP_PENDING;
329
330	::SetEvent(stop);
331
332	break;
333
334	case SERVICE_CONTROL_INTERROGATE:
335	break;
336	}
337
338	::SetServiceStatus(handle, &status);
339	}