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 608 by douglas, 2005-11-30T18:23:39-08:00 vs.
Revision 612 by douglas, 2005-12-05T02:32:27-08:00

# Line 11 | Line 11
11  
12   #include <iostream>
13   #include <string>
14 + #include <sstream>
15 + #include <vector>
16  
17 < 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[])
17 > inline std::string Utf8(const std::wstring &wstring)
18   {
19 <        PWTS_SESSION_INFO sessions;
29 <        DWORD count;
19 >        std::string string(WideCharToMultiByte(CP_UTF8, 0, wstring.data(), int(wstring.size()), NULL, 0, NULL, NULL), '\0');
20  
21 <        if (!WTSEnumerateSessions(WTS_CURRENT_SERVER_HANDLE, 0, 1, &sessions, &count))
32 <        {
33 <                std::cerr << GetLastError() << std::endl;
21 >        WideCharToMultiByte(CP_UTF8, 0, wstring.data(), int(wstring.size()), const_cast<LPSTR>(string.data()), int(string.size()), NULL, NULL);
22  
23 <                return 1;
24 <        }
23 >        return string;
24 > }
25 >
26 > class Finger
27 > {
28 > private:
29 >        std::ostringstream stream;
30  
31 <        for (PWTS_SESSION_INFO session = sessions; session != sessions + count; ++session)
31 > public:
32 >        Finger(bool full)
33          {
34 <                LPTSTR userName, clientName;
35 <                DWORD userNameSize, clientNameSize;
34 >                if (!full)
35 >                        stream << "Login\t\tName\t\tTTY\r\n";
36  
37 <                WTSQuerySessionInformation(WTS_CURRENT_SERVER_HANDLE, session->SessionId, WTSUserName, &userName, &userNameSize);
38 <                WTSQuerySessionInformation(WTS_CURRENT_SERVER_HANDLE, session->SessionId, WTSClientName, &clientName, &clientNameSize);
37 >                PWTS_SESSION_INFO sessions;
38 >                DWORD count;
39  
40 <                std::wcout << '{' << std::endl
47 <                        << '\t' << session->SessionId << std::endl
48 <                        << '\t' << session->pWinStationName << std::endl
49 <                        << '\t';
40 >                WTSEnumerateSessions(WTS_CURRENT_SERVER_HANDLE, 0, 1, &sessions, &count);
41  
42 <                switch (session->State)
42 >                for (PWTS_SESSION_INFO session = sessions; session != sessions + count; ++session)
43                  {
44 <                case WTSActive:
45 <                        std::cout << "Active";
55 <                        
56 <                        break;
57 <                case WTSConnected:
58 <                        std::cout << "Connected";
44 >                        LPTSTR name;
45 >                        DWORD size;
46  
47 <                        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";
47 >                        WTSQuerySessionInformation(WTS_CURRENT_SERVER_HANDLE, session->SessionId, WTSUserName, &name, &size);
48  
49 <                        break;
73 <                case WTSIdle:
74 <                        std::cout << "Idle";
49 >                        std::string name_(Utf8(name));
50  
51 <                        break;
52 <                case WTSListen:
78 <                        std::cout << "Listen";
51 >                        if (!name_.empty())
52 >                                stream << name_ << "\r\n";
53  
54 <                        break;
81 <                case WTSReset:
82 <                        std::cout << "Reset";
83 <
84 <                        break;
85 <                case WTSDown:
86 <                        std::cout << "Down";
54 >                        WTSFreeMemory(name);
55  
56 <                        break;
57 <                case WTSInit:
58 <                        std::cout << "Init";
91 <
92 <                        break;
56 >                        //PWTS_CLIENT_ADDRESS address;
57 >                        //WTSQuerySessionInformation(WTS_CURRENT_SERVER_HANDLE, session->SessionId, WTSClientAddress, reinterpret_cast<LPTSTR *>(&address), &size);
58 >                        //WTSFreeMemory(address);
59                  }
60  
61 <                std::wcout << std::endl << '\t' << userName << std::endl
62 <                        << '\t' << clientName << std::endl
97 <                        << '}' << std::endl;
61 >                WTSFreeMemory(sessions);
62 >        }
63  
64 <                WTSFreeMemory(userName);
65 <                WTSFreeMemory(clientName);
64 >        Finger(const std::string &name)
65 >        {
66 >                //NetQueryDisplayInformation
67 >                //NetUserGetInfo
68          }
69  
70 <        WTSFreeMemory(sessions);
70 >        inline operator std::string()
71 >        {
72 >                return stream.str();
73 >        }
74 > };
75  
76 <        /*SERVICE_TABLE_ENTRY entry[] = { { TEXT("CCS Finger Daemon"), LPSERVICE_MAIN_FUNCTION(FingerMain) }, { NULL, NULL } };
76 > LPTSTR name;
77 > SERVICE_STATUS status;
78 > SERVICE_STATUS_HANDLE handle;
79 > HANDLE stop;
80 > WSADATA data;
81 > std::vector<HANDLE> threads;
82 >
83 > void FingerDaemon();
84 > DWORD WINAPI FingerListen(LPVOID server_);
85 > DWORD WINAPI FingerDo(LPVOID client_);
86 > void FingerStop(int);
87 > void WINAPI FingerMain(DWORD argc, LPTSTR *argv);
88 > void WINAPI FingerControl(DWORD control);
89 >
90 > int _tmain(int argc, TCHAR *argv[])
91 > {
92 >        SERVICE_TABLE_ENTRY entry[] = { { TEXT("CCS Finger Daemon"), LPSERVICE_MAIN_FUNCTION(FingerMain) }, { NULL, NULL } };
93  
94          if (!StartServiceCtrlDispatcher(entry))
95          {
# Line 143 | Line 130 | go:
130          }
131          catch (...) {}
132  
133 <        return 0;*/
133 >        return 0;
134   }
135  
136   void FingerDaemon()
# Line 162 | Line 149 | void FingerDaemon()
149          bind(server, (SOCKADDR *)(&service), sizeof (service));
150          listen(server, SOMAXCONN);
151  
152 <        SOCKET client;
152 >        threads.push_back(CreateThread(NULL, 0, FingerListen, &server, 0, NULL));
153  
154 <        while(WaitForSingleObject(stop, 1000) != WAIT_OBJECT_0 && (client = accept(server, NULL, NULL)) == SOCKET_ERROR)
168 <        {
169 <                //
170 <        }
154 >        while(WaitForSingleObject(stop, 1000) != WAIT_OBJECT_0);
155  
156          //
157  
# Line 176 | Line 160 | void FingerDaemon()
160          WSACleanup();
161   }
162  
163 + DWORD WINAPI FingerListen(LPVOID server_)
164 + {
165 +        SOCKET &server(*reinterpret_cast<SOCKET *>(server_));
166 +
167 +        while (true)
168 +        {
169 +                SOCKET client(accept(server, NULL, NULL));
170 +
171 +                threads.push_back(CreateThread(NULL, 0, FingerDo, &client, 0, NULL));
172 +        }
173 +
174 +        return 0;
175 + }
176 +
177 + DWORD WINAPI FingerDo(LPVOID client_)
178 + {
179 +        SOCKET &client(*reinterpret_cast<SOCKET *>(client_));
180 +        char buffer[1024];
181 +        std::istringstream stream(std::string(buffer, recv(client, buffer, sizeof buffer, 0)));
182 +        std::string line;
183 +
184 +        std::getline(stream, line);
185 +
186 +        stream.str(line);
187 +
188 +        std::getline(stream, line, '\r');
189 +
190 +        stream.str(line);
191 +
192 +        std::string name;
193 +        bool full(false);
194 +
195 +        while (stream >> line)
196 +                if (line == "/W")
197 +                        full = true;
198 +                else
199 +                        name = line;
200 +
201 +        std::string finger(name.empty() ? Finger(full) : Finger(name));
202 +
203 +        send(client, finger.data(), int(finger.size()), 0);
204 +        closesocket(client);
205 +
206 +        return 0;
207 + }
208 +
209   void FingerStop(int)
210   {
211          SetEvent(stop);
182 –
183 –        std::cout << "Stop!" << std::endl;
212   }
213  
214   void WINAPI FingerMain(DWORD argc, LPTSTR *argv)

Diff Legend

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