远程打开telnet服务opentelnet程序代码

猪猪

信息来源:refdom

opentelnet.cpp

1. ////////////////////////////////////////////////////////////////////////////////
   
2. //     
   
3. //     Resume Telnet Remote Config
   
4. //     
   
5. //     File     : ReumeTelnet.cpp
   
6. //     Version   : 0.5
   
7. //     Comment   : only for win2k and XP(pro\server\adv)
   
8. //     
   
9. //     Create at : 2002.3.9
   
10. //     Create by : refdom
    
11. //            Email       : [email]refdom@263.net[/email]
    
12. //            Home Page : [url]www.opengram.com[/url]
    
13. //
    
14. //            If you modify the code, or add more functions, please email me a copy.
    
15. //     
    
16. ////////////////////////////////////////////////////////////////////////////////
    
17. 
    
18. #include <stdio.h>
    
19. #include <windows.h>
    
20. 
    
21. #pragma comment(lib, "Advapi32.lib")
    
22. #pragma comment(lib, "Mpr.lib")
    
23. 
    
24. SC_HANDLE      g_schSCManager;
    
25. SC_HANDLE   g_schRegistryService;
    
26. HKEY            g_hKey;
    
27. DWORD            g_DefaultTelnetStartType = 0;
    
28. DWORD            g_DefaultRegistryStartType = 0;
    
29. LPBYTE            g_lpDefaultTelnetNTLM;
    
30. LPBYTE            g_lpDefaultTelnetPort;
    
31. 
    
32. void Usage(char*);
    
33. int CloseTelnet();
    
34. int StartRemoteRegistry();
    
35. int MyStartService(SC_HANDLE, char*);
    
36. int ResumeRegistryService();
    
37. 
    
38. int main(int argc, char* argv[])
    
39. {
    
40.      int nRetCode;
    
41.      char szIpc[50] = "";
    
42.      HKEY hKey;
    
43.      LPSTR lpUserName, lpPassword;
    
44.      NETRESOURCE NET;
    
45. 
    
46.      Usage(argv[0]);
    
47.      if (argc != 4)
    
48.            return 0;
    
49. 
    
50.      sprintf (szIpc, "%s\\ipc$", argv[1]);
    
51.      lpUserName = argv[2];
    
52.      lpPassword = argv[3];
    
53. 
    
54.      NET.lpLocalName = NULL;
    
55.      NET.lpRemoteName = szIpc;
    
56.      NET.dwType = RESOURCETYPE_ANY;
    
57.      NET.lpProvider = NULL;
    
58. 
    
59.      printf ("Connecting %s...",argv[1]);
    
60. 
    
61. ReConnect:
    
62. 
    
63.      nRetCode = WNetCancelConnection2(szIpc, CONNECT_UPDATE_PROFILE, TRUE);
    
64.      if (nRetCode == NO_ERROR)
    
65.            printf ("Canncel Successfully!\n");
    
66. 
    
67.      nRetCode = WNetAddConnection2(&NET, lpPassword, lpUserName, CONNECT_INTERACTIVE);
    
68.      if (nRetCode == ERROR_ALREADY_ASSIGNED || nRetCode == ERROR_DEVICE_ALREADY_REMEMBERED)
    
69.      {
    
70.            printf ("Already conneted to the server!\n");
    
71.            printf ("Now re-connecting the server...\n");
    
72.            goto ReConnect;
    
73.      }
    
74.      else if (nRetCode == NO_ERROR)
    
75.            printf ("Successfully!\n");
    
76.      else
    
77.      {
    
78.            printf ("\n\tErr:");
    
79.            switch (nRetCode)
    
80.            {
    
81.            case ERROR_ACCESS_DENIED:
    
82.                  printf ("ERROR_ACCESS_DENIED\n");
    
83.                  break;
    
84.            case ERROR_BAD_NET_NAME:
    
85.                  printf ("ERROR_BAD_NET_NAME\n");
    
86.                  break;
    
87.            default:
    
88.                  printf ("CONNECT ERR:%d!\n",GetLastError());
    
89.                  break;
    
90.            }
    
91.            return 0;
    
92.      }
    
93. 
    
94.      //open SCManager
    
95.      g_schSCManager = OpenSCManager(argv[1], NULL, SC_MANAGER_ALL_ACCESS);
    
96.      if (g_schSCManager == NULL)
    
97.      {
    
98.            printf ("Open SCManager failed!\n");
    
99.            return 0;
    
100.      }
     
101. 
     
102.      //check remote registry service is running
     
103.      if (!StartRemoteRegistry())
     
104.      {
     
105.            printf ("All Process Failed!\n");
     
106.            return 0;
     
107.      }
     
108. 
     
109.      //edit the registry
     
110.      if (!(RegConnectRegistry((LPCTSTR) argv[1], HKEY_LOCAL_MACHINE, &g_hKey) == ERROR_SUCCESS))
     
111.      {
     
112.            printf ("Connect remote registry failed!\n");
     
113.            return 0;
     
114.      }
     
115. 
     
116.      if (!(RegOpenKeyEx(g_hKey, "SOFTWARE\\Microsoft\\TelnetServer\\1.0", 0, KEY_ALL_ACCESS, &hKey) == ERROR_SUCCESS))
     
117.      {
     
118.            printf ("Open key failed!\n");
     
119.            return 0;
     
120.      }
     
121. 
     
122.      //read the registry for default config
     
123.      g_lpDefaultTelnetNTLM = (LPBYTE) LocalAlloc(LPTR, 50);
     
124.      g_lpDefaultTelnetPort = (LPBYTE) LocalAlloc(LPTR, 50);
     
125.      DWORD dwDataSize = 50;
     
126.      if (!(RegQueryValueEx(hKey, "default_NTLM", NULL, NULL, g_lpDefaultTelnetNTLM, &dwDataSize) == ERROR_SUCCESS))
     
127.      {
     
128.            printf ("Read NTLM failed!\n ");
     
129.            printf ("%d\n", GetLastError());
     
130.            return 0;
     
131.      }
     
132.      if (!(RegQueryValueEx(hKey, "default_Port", NULL, NULL, g_lpDefaultTelnetPort, &dwDataSize) == ERROR_SUCCESS))
     
133.      {
     
134.            printf ("Read port failed!\n ");
     
135.            return 0;
     
136.      }
     
137.      if (!(RegQueryValueEx(hKey, "default_RegistryStart", NULL, NULL, (LPBYTE) &g_DefaultRegistryStartType, &dwDataSize) == ERROR_SUCCESS))
     
138.      {
     
139.            printf ("Read registrystart failed!\n ");
     
140.            return 0;
     
141.      }
     
142.      if (!(RegQueryValueEx(hKey, "default_TelnetStart", NULL, NULL, (LPBYTE) &g_DefaultTelnetStartType, &dwDataSize) == ERROR_SUCCESS))
     
143.      {
     
144.            printf ("Read telnetstart failed!\n ");
     
145.            return 0;
     
146.      }
     
147.      if (!(RegSetValueEx(hKey, "NTLM", 0, REG_DWORD, g_lpDefaultTelnetNTLM, sizeof(DWORD)) == ERROR_SUCCESS))
     
148.      {
     
149.            printf ("Set NTLM failed!");
     
150.            return 0;
     
151.      }
     
152. 
     
153.      if (!(RegSetValueEx(hKey, "TelnetPort", 0, REG_DWORD, g_lpDefaultTelnetPort, sizeof(DWORD)) == ERROR_SUCCESS))
     
154.      {
     
155.            printf ("Set port failed!");
     
156.            return 0;
     
157.      }
     
158. 
     
159.      //close telnet service
     
160.      nRetCode = CloseTelnet();
     
161. 
     
162.      if (nRetCode)
     
163.      {
     
164.            printf ("\nBINGLE!!!\n");
     
165.            printf ("The config of remote telnet server is resumed!\n");
     
166.      }
     
167. 
     
168.      //resume the configure
     
169.      if (!(RegDeleteValue(hKey, (LPCTSTR) "default_NTLM") == ERROR_SUCCESS))
     
170.            printf ("Delete NTLM value failed!\n");
     
171.      if (!(RegDeleteValue(hKey, (LPCTSTR) "default_Port") == ERROR_SUCCESS))
     
172.            printf ("Delete port value failed!\n");
     
173.      if (!(RegDeleteValue(hKey, (LPCTSTR) "default_RegistryStart") == ERROR_SUCCESS))
     
174.            printf ("Delete registrystart value failed!\n");
     
175.      if (!(RegDeleteValue(hKey, (LPCTSTR) "default_TelnetStart") == ERROR_SUCCESS))
     
176.            printf ("Delete telnetstart value failed!\n");
     
177. 
     
178.      RegCloseKey(hKey);
     
179.      RegCloseKey(g_hKey);
     
180. 
     
181.      ResumeRegistryService();
     
182.      CloseServiceHandle(g_schRegistryService);
     
183.      //close SCManager
     
184.      CloseServiceHandle(g_schSCManager);
     
185. 
     
186.      //close the session with remote server
     
187.      printf ("\nDisconnecting server...");
     
188.      nRetCode = WNetCancelConnection2(argv[1], CONNECT_UPDATE_PROFILE, TRUE);
     
189.      if (nRetCode == NO_ERROR)
     
190.            printf ("Successfully!\n");
     
191.      else
     
192.            printf ("Failed!\n");
     
193. 
     
194.      LocalFree(g_lpDefaultTelnetNTLM);
     
195.      LocalFree(g_lpDefaultTelnetPort);
     
196. 
     
197.      return 0;
     
198. }
     
199. 
     
200. void Usage(char* pcAppName)
     
201. {
     
202.      printf ("*******************************************************\n");
     
203.      printf ("Resume Remote Telnet Config, by refdom\n");
     
204.      printf ("Email: [email]refdom@263.net[/email]\n");
     
205.      printf ("%s\n\n", pcAppName);
     
206.      printf ("Usage:ResumeTelnet.exe \\\\server username password\n");
     
207.      printf ("*******************************************************\n");
     
208.      return;
     
209. }
     
210. 
     
211. int CloseTelnet()
     
212. {
     
213.      DWORD                              dwWaitTime;
     
214.      DWORD                              dwConfigSize;
     
215.      SC_HANDLE                        schTelnetService;
     
216.      SERVICE_STATUS                  ssTelnetStatus;
     
217.      LPQUERY_SERVICE_CONFIG      lpTelnetConfig;
     
218. 
     
219.      //stop the telnet service
     
220.      schTelnetService = OpenService(g_schSCManager, "TlntSvr", SERVICE_ALL_ACCESS);
     
221.      if (schTelnetService == NULL)
     
222.      {
     
223.            printf ("Open service failed!\n");
     
224.            return 0;
     
225.      }
     
226. 
     
227.      lpTelnetConfig = (LPQUERY_SERVICE_CONFIG) LocalAlloc(LPTR, 1024);
     
228.      if (lpTelnetConfig == NULL)
     
229.      {
     
230.            printf ("Alloc memory failed!\n");
     
231.            return 0;
     
232.      }
     
233.      if (!QueryServiceConfig(schTelnetService, lpTelnetConfig, 1024, &dwConfigSize))
     
234.      {
     
235.            printf ("Query service congfig failed!\n");
     
236.            return 0;
     
237.      }
     
238. 
     
239.      if (lpTelnetConfig->dwStartType != g_DefaultTelnetStartType)
     
240.      {
     
241.            if (!ChangeServiceConfig(schTelnetService,
     
242.                                          SERVICE_NO_CHANGE,
     
243.                                          g_DefaultTelnetStartType,
     
244.                                          SERVICE_NO_CHANGE,
     
245.                                          NULL, NULL, NULL, NULL, NULL, NULL, NULL))
     
246.            {
     
247.                  printf ("Set telnet start type error!\n");
     
248.                  return 0;
     
249.            }
     
250.      }
     
251. 
     
252.      if (!(QueryServiceStatus(schTelnetService, &ssTelnetStatus)))
     
253.      {
     
254.            printf ("Query service status failed!\n");
     
255.            return 0;
     
256.      }
     
257. 
     
258.      if (ssTelnetStatus.dwCurrentState != SERVICE_STOPPED && ssTelnetStatus.dwCurrentState != SERVICE_STOP_PENDING)
     
259.      {
     
260.            printf ("Stopping telnet service ...\n");
     
261.            if (!(ControlService(schTelnetService, SERVICE_CONTROL_STOP, &ssTelnetStatus)))
     
262.            {
     
263.                  printf ("Control telnet service status failed!\n");
     
264.                  return 0;
     
265.            }
     
266. 
     
267.            dwWaitTime = ssTelnetStatus.dwWaitHint / 10;
     
268.            if( dwWaitTime < 1000 )
     
269.                  dwWaitTime = 1000;
     
270.            else if ( dwWaitTime > 10000 )
     
271.                  dwWaitTime = 10000;
     
272. 
     
273.            Sleep(dwWaitTime);
     
274.            if (!QueryServiceStatus(schTelnetService, &ssTelnetStatus))
     
275.            {
     
276.                  printf ("Query service status failed!\n");
     
277.            }
     
278. 
     
279.            if ( ssTelnetStatus.dwCurrentState == SERVICE_STOPPED || ssTelnetStatus.dwCurrentState == SERVICE_STOP_PENDING)
     
280.            {
     
281.                  printf ("Telnet service is stopped successfully!\n");
     
282.            }
     
283.            else
     
284.            {
     
285.                  printf ("Stopping telnet service failed!\n");
     
286.                  return 0;
     
287.            }
     
288.      }
     
289. 
     
290.      LocalFree(lpTelnetConfig);
     
291.      CloseServiceHandle(schTelnetService);
     
292.      return 1;
     
293. }
     
294. 
     
295. int StartRemoteRegistry()
     
296. {
     
297.      SC_HANDLE                        schRegistryService;
     
298.      SERVICE_STATUS                  ssRegistryStatus;
     
299. 
     
300.      schRegistryService = OpenService( g_schSCManager, "RemoteRegistry", SERVICE_ALL_ACCESS);
     
301.      g_schRegistryService = OpenService( g_schSCManager, "RemoteRegistry", SERVICE_ALL_ACCESS);;
     
302. 
     
303.      if (schRegistryService == NULL || g_schRegistryService == NULL)
     
304.      {
     
305.            printf ("Open remote registry service failed!\n");
     
306.            return 0;
     
307.      }
     
308. 
     
309.      if (!QueryServiceStatus(schRegistryService, &ssRegistryStatus))
     
310.      {
     
311.            printf ("Query remote registry service failed!\n");
     
312.            return 0;
     
313.      }
     
314. 
     
315.      if (ssRegistryStatus.dwCurrentState != SERVICE_RUNNING)
     
316.      {
     
317.            if (!MyStartService(schRegistryService, "remote registry"))
     
318.                  return 0;
     
319.      }
     
320. 
     
321.      CloseServiceHandle(schRegistryService);
     
322.      return 1;
     
323. }
     
324. 
     
325. int MyStartService(SC_HANDLE schService, char* szServiceName)
     
326. {
     
327.      DWORD dwWaitTime;
     
328.      DWORD dwOldCheckPoint;
     
329.      DWORD dwStartTickCount;
     
330.      SERVICE_STATUS ssStatus;
     
331. 
     
332.      printf ("Starting %s service...\n", szServiceName);
     
333.      if (!(StartService(schService, 0, NULL)))
     
334.      {
     
335.            printf ("Starting %s service failed!\n", szServiceName);
     
336.            return 0;
     
337.      }
     
338. 
     
339.      if (!(QueryServiceStatus(schService, &ssStatus)))
     
340.      {
     
341.            printf ("Query %s service status failed!\n",szServiceName);
     
342. //            return ;
     
343.      }
     
344. 
     
345.   dwStartTickCount = GetTickCount();
     
346.   dwOldCheckPoint = ssStatus.dwCheckPoint;
     
347. 
     
348.      while ( ssStatus.dwCurrentState == SERVICE_START_PENDING)
     
349.      {
     
350.            dwWaitTime = ssStatus.dwWaitHint / 10;
     
351.     if( dwWaitTime < 1000 )
     
352.         dwWaitTime = 1000;
     
353.     else if ( dwWaitTime > 10000 )
     
354.         dwWaitTime = 10000;
     
355. 
     
356.            Sleep(dwWaitTime);
     
357. 
     
358.     // Check the status again.
     
359. 
     
360.     if (!QueryServiceStatus(schService, &ssStatus))
     
361.         break;
     
362. 
     
363.     if ( ssStatus.dwCheckPoint > dwOldCheckPoint )
     
364.     {
     
365.         // The service is making progress.
     
366.         dwStartTickCount = GetTickCount();
     
367.         dwOldCheckPoint = ssStatus.dwCheckPoint;
     
368.     }
     
369.     else
     
370.     {
     
371.         if(GetTickCount()-dwStartTickCount > ssStatus.dwWaitHint)
     
372.         {
     
373.           // No progress made within the wait hint
     
374.           break;
     
375.         }
     
376.     }
     
377.      }
     
378. 
     
379.      if ( ssStatus.dwCurrentState == SERVICE_RUNNING )
     
380.      {
     
381.            printf ("%s service is started successfully! %s service is running!\n", szServiceName, szServiceName);
     
382.      }
     
383.      else
     
384.      {
     
385.            printf ("%s service is not started!\n", szServiceName);
     
386.            return 0;
     
387.      }
     
388. 
     
389.      return 1;
     
390. }
     
391. 
     
392. int ResumeRegistryService()
     
393. {
     
394.      LPQUERY_SERVICE_CONFIG      lpRegistryConfig;
     
395.      DWORD                              dwConfigSize;
     
396. 
     
397.      lpRegistryConfig = (LPQUERY_SERVICE_CONFIG) LocalAlloc(LPTR, 1024);
     
398.      if (lpRegistryConfig == NULL)
     
399.      {
     
400.            printf ("Alloc memory failed!\n");
     
401.            return 0;
     
402.      }
     
403.      if (!QueryServiceConfig(g_schRegistryService, lpRegistryConfig, 1024, &dwConfigSize))
     
404.      {
     
405.            printf ("Query registry service congfig failed!\n");
     
406.            printf ("%d\n",GetLastError());
     
407.            return 0;
     
408.      }
     
409. 
     
410.      if (lpRegistryConfig->dwStartType != g_DefaultRegistryStartType)
     
411.      {
     
412.            if (!ChangeServiceConfig(g_schRegistryService,
     
413.                                                SERVICE_NO_CHANGE,
     
414.                                                g_DefaultRegistryStartType,
     
415.                                                SERVICE_NO_CHANGE,
     
416.                                                NULL, NULL, NULL, NULL, NULL, NULL, NULL))
     
417.            {
     
418.                  printf ("Set registry start type error!\n");
     
419.                  return 0;
     
420.            }
     
421.      }
     
422. 
     
423.      LocalFree(lpRegistryConfig);
     
424.      return 1;
     
425. }

复制代码