ViewVC Help
View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing
root/repos/CCSFinger/CCSFinger.cpp
(Generate patch)

Comparing CCSFinger/CCSFinger.cpp (file contents):
Revision 594 by douglas, 2005-11-27T17:04:53-08:00 vs.
Revision 608 by douglas, 2005-11-30T18:23:39-08:00

# Line 6 | Line 6
6  
7   #include <windows.h>
8   #include <tchar.h>
9 + #include <signal.h>
10 + #include <wtsapi32.h>
11  
12 < /*LPTSTR name;
12 > #include <iostream>
13 > #include <string>
14 >
15 > LPTSTR name;
16   SERVICE_STATUS status;
17   SERVICE_STATUS_HANDLE handle;
18 < HANDLE stop;*/
18 > HANDLE stop;
19   WSADATA data;
20  
21 < /*void WINAPI FingerMain(DWORD argc, LPTSTR *argv);
22 < void WINAPI FingerControl(DWORD control);*/
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))
# Line 27 | Line 111 | int _tmain(int argc, TCHAR *argv[])
111                  switch (error)
112                  {
113                  case ERROR_FAILED_SERVICE_CONTROLLER_CONNECT:
114 <                        std::cerr << "ERROR_FAILED_SERVICE_CONTROLLER_CONNECT" << std::endl;
31 <
32 <                        break;
114 >                        goto go;
115  
116                  case ERROR_INVALID_DATA:
117                          std::cerr << "ERROR_INVALID_DATA" << std::endl;
# Line 49 | Line 131 | int _tmain(int argc, TCHAR *argv[])
131          }
132  
133          return 0;
52 – }
134  
135 < void WINAPI FingerMain(DWORD argc, LPTSTR *argv)
55 < {
56 <        name = argv[0];
57 <        handle = RegisterServiceCtrlHandler(name, LPHANDLER_FUNCTION(FingerControl));
135 > go:
136          stop = CreateEvent(NULL, TRUE, FALSE, NULL);
137  
138 <        //*/
138 >        signal(SIGINT, FingerStop);
139  
140 <        WSAStartup(MAKEWORD(2, 0), &data);
140 >        try
141 >        {
142 >                FingerDaemon();
143 >        }
144 >        catch (...) {}
145  
146 <        //
146 >        return 0;*/
147 > }
148  
149 <        /*status.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
150 <        status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
151 <        status.dwServiceSpecificExitCode = 0;
69 <        status.dwCurrentState = SERVICE_RUNNING;
70 <        status.dwWin32ExitCode = NO_ERROR;
71 <        status.dwCheckPoint = 0;
72 <        status.dwWaitHint = 0;
149 > void FingerDaemon()
150 > {
151 >        WSAStartup(MAKEWORD(2, 0), &data);
152  
153 <        SetServiceStatus(handle, &status);*/
153 >        //
154  
155 <        SOCKET sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
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(sock, (SOCKADDR *)(&service), sizeof (service));
163 <        listen(sock, SOMAXCONN);
162 >        bind(server, (SOCKADDR *)(&service), sizeof (service));
163 >        listen(server, SOMAXCONN);
164  
165 <        //while(/*WaitForSingleObject(stop, 1000) != WAIT_OBJECT_0*/ /*&&*/)
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 <        /*status.dwCurrentState = SERVICE_STOPPED;
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;
# Line 116 | Line 231 | void WINAPI FingerControl(DWORD control)
231                  break;
232          }
233  
234 <        SetServiceStatus(handle, &status);*/
120 <
121 <        return 0;
234 >        SetServiceStatus(handle, &status);
235   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines