////////////////////////////////////////////////////////////////////////////////
//      
//      Enum Service
//      
//      File      : EnumService.cpp
//      
//      Create at : 2002.3.10
//      Create by : refdom
//		Email	  : refdom@263.net
//		Home Page : www.opengram.com
//
//		If you modify the code, or add more functions, please email me a copy.
//      
////////////////////////////////////////////////////////////////////////////////
#include "ConnectServer.h"
#include <stdio.h>
#include <windows.h>
#include <Winnetwk.h>
#include <Shlwapi.h>

#pragma comment(lib, "Advapi32.lib")
#pragma comment(lib, "Mpr.lib")

DWORD g_dwManagerAccess = SC_MANAGER_ALL_ACCESS;
DWORD g_dwServiceAccess = SERVICE_ALL_ACCESS;

void ListServices (SC_HANDLE, DWORD);
void MyStartService (SC_HANDLE, LPSTR);
void MyStopService (SC_HANDLE, LPSTR);
void MyViewService (SC_HANDLE, LPSTR);
void Usage(char*);

int main(int argc, char* argv[])
{
	int nRetCode = 0;
	char szIpc[50] = "";
	DWORD dwServiceType;
	SC_HANDLE schSCManager;
	LPSTR lpUserName, lpPassword, lpServiceName;
	NETRESOURCE NET;

	if (argc < 2)
	{
		Usage(argv[0]);
		return 0;
	}

	if (argv[1][0] == '/' && strlen(argv[1]) == 2)
	{
		switch (tolower(argv[1][1]))
		{
		case 'l':
			dwServiceType = SERVICE_WIN32 | SERVICE_DRIVER;
			break;
		case 'd':
			dwServiceType = SERVICE_DRIVER;
			break;
		case 'w':
			dwServiceType = SERVICE_WIN32;
			break;
		case 'k':
			dwServiceType = SERVICE_KERNEL_DRIVER;
			break;
		case 'f':
			dwServiceType = SERVICE_FILE_SYSTEM_DRIVER;
			break;
		case 'o':
			dwServiceType = SERVICE_WIN32_OWN_PROCESS;
			break;
		case 'h':
			dwServiceType = SERVICE_WIN32_SHARE_PROCESS;
			break;
		case 'r':
			dwServiceType = -1;
			break;
		case 's':
		case 'p':
		case 'v':
			if (argc < 6 && (argc != 3))
			{
				printf ("Error! Input a service name!\n");
				return 0;
			}
			else if (argc >6)
			{
				printf ("Error! A wrong service name!\n");
				return 0;
			}
			break;
		case '?':
			Usage(argv[0]);
			return 0;
		default:
			printf ("Error: Unknow option!\n");
			return 0;;
		}
	}
	else
	{
		printf ("Error: Unknow option!\n");
		return 0;
	}

	//get service name
	if (argc == 6)
	{
		lpServiceName = argv[5];
	}
	else if (argc == 3)
	{
//		if ((argv[2][0] != '\\') && (argv[2][1] != '\\'))
//		{
	if (argv[1][0] == '/' && strlen(argv[1]) == 2)
	{
		switch (tolower(argv[1][1]))
		{
		case 'l':
		case 'd':
		case 'w':
		case 'k':
		case 'f':
		case 'o':
		case 'h':
		case 'r':
			printf ("Error arguments!\n");
			return 0;
		default:
			lpServiceName = argv[2];
			break;
		}
	}
//			lpServiceName = argv[2];
//		}
	}

	if (argc > 3)
	{
/*		if ((argv[2][0] != '\\') && (argv[2][1] != '\\'))
		{
			schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
		}
		else
		{
			if (argc == 3)
			{
				lpUserName = "";
				lpPassword = "";
				//change access
				g_dwManagerAccess = SC_MANAGER_CONNECT;
				g_dwServiceAccess = GENERIC_READ;
				sprintf (szIpc, "%s", argv[2]);
			}
			else
			{
*/
				lpUserName = argv[3];
				lpPassword = argv[4];
				sprintf (szIpc, "%s\\ipc$", argv[2]);
//			}

			NET.lpLocalName = NULL;
			NET.lpRemoteName = szIpc;
			NET.dwType = RESOURCETYPE_ANY;
			NET.lpProvider = NULL;

			printf ("Connecting %s...",argv[2]);

			nRetCode = MyConnectServer(&NET, lpPassword, lpUserName, CONNECT_INTERACTIVE, szIpc);
			if (!nRetCode)
				printf ("Successfully!\n");
			else
			{
				printf ("Failed!\n");
			}
			schSCManager = OpenSCManager(argv[2], NULL, SC_MANAGER_ALL_ACCESS);
//		}
	}
	else
	{
		schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
	}

	if (schSCManager == NULL)
	{
		printf ("%d\n", argc);
		printf ("%d\n", GetLastError());
		printf ("Open SCManager failed!\n");
		return 0;
	}

	//
	switch (tolower(argv[1][1]))
	{
	case 'l':
	case 'd':
	case 'w':
	case 'k':
	case 'f':
	case 'o':
	case 'h':
	case 'r':
		ListServices(schSCManager, dwServiceType);
		break;
	case 's':
		MyStartService(schSCManager, lpServiceName);
		break;
	case 'p':
		MyStopService(schSCManager, lpServiceName);
		break;
	case 'v':
		MyViewService(schSCManager, lpServiceName);
		break;
	}

	CloseServiceHandle(schSCManager);

	if (argc >3 )
	{
		//close the session with remote server
		printf ("\nDisconnecting server...");
		nRetCode = MyDisConnectServer(szIpc, CONNECT_UPDATE_PROFILE, TRUE);
		if (!nRetCode)
			printf ("Successfully!\n");
		else
			printf ("Failed!\n");
	}

	return 0;
}

void ListServices(SC_HANDLE schSCManager, DWORD ServiceType)
{
	//list services
	LPENUM_SERVICE_STATUS_PROCESS lpServices;
	DWORD n;
	DWORD nSize = 0;
	DWORD nServicesReturned;
	DWORD nResumeHandle;
	DWORD dwServiceType;
	nResumeHandle = 0;
	dwServiceType = ServiceType;
	if (ServiceType == -1)
	{
		dwServiceType = SERVICE_WIN32;
	}

	lpServices = (LPENUM_SERVICE_STATUS_PROCESS) LocalAlloc(LPTR, 30720);

	if (EnumServicesStatusEx(schSCManager, SC_ENUM_PROCESS_INFO, 
		                     dwServiceType, SERVICE_STATE_ALL, 
							 (LPBYTE)lpServices, 30720, 
							 &nSize, &nServicesReturned,
							 &nResumeHandle, NULL) == NULL)
	{
		printf ("Enum Error!%d\n",GetLastError());
		return;
	}
	else
	{
		printf ("Listing service...\n\n");
	}
	
	printf ("------------------------------------------------------\n");
	printf ("PID \t ServiceName {Service Display Name} <Current status>\n");
	printf ("------------------------------------------------------\n");
	for (n = 0; n < nServicesReturned; n++)
	{
		if (!(ServiceType == -1 
			&& lpServices[n].ServiceStatusProcess.dwCurrentState != SERVICE_RUNNING))
		{
			//Show the name of service
			printf ("pid:%d.",lpServices[n].ServiceStatusProcess.dwProcessId);
			if (lpServices[n].ServiceStatusProcess.dwProcessId == 0 )
			{
				printf ("\t");
			}
			printf ("%s\t{%s}", lpServices[n].lpServiceName, lpServices[n].lpDisplayName);
//			printf ("\t");
			//Show the status of service
			switch (lpServices[n].ServiceStatusProcess.dwCurrentState)
			{
			case SERVICE_STOPPED:
				printf ("<not running.>");
				break;
			case SERVICE_START_PENDING:
				printf ("<starting.>");
				break;
			case SERVICE_STOP_PENDING:
				printf ("<stopping.>");
				break;
			case SERVICE_RUNNING:
				printf ("<running.>");
				break;
			case SERVICE_CONTINUE_PENDING:
				printf ("<continue pending.>");
				break;
			case SERVICE_PAUSE_PENDING:
				printf ("<pause pending.>");
				break;
			case SERVICE_PAUSED:
				printf ("<paused.>");
				break;
			}
			printf ("\n");
		}
	}
	return;
}

void MyStartService(SC_HANDLE schSCManager, LPSTR lpServiceName)
{
	SC_HANDLE schService;
	DWORD dwWaitTime;
	DWORD dwOldCheckPoint = 0;
	DWORD dwStartTickCount;
	SERVICE_STATUS ssStatus;
	LPQUERY_SERVICE_CONFIG lpConfig;
	DWORD dwSize;

	schService = OpenService(schSCManager, lpServiceName, SERVICE_ALL_ACCESS);