public void ChangeConfig( SERVICE_TYPE serviceType, SERVICE_START_TYPE startType, SERVICE_ERROR_CONTROL errorControl, string binaryPathName, string loadOrderGroup, IntPtr tagId, IEnumerable <string> dependencies, string serviceStartName, string password, string displayName) { var dependenciesString = dependencies == null ? null : string.Join("\0", dependencies) + "\0"; // Collection of strings separated by null and terminated by double null if (!NativeMethods.ChangeServiceConfig( handle, (uint)serviceType, (uint)startType, (uint)errorControl, binaryPathName, loadOrderGroup, tagId, dependenciesString, serviceStartName, password, displayName)) { throw new Win32Exception(); } }
public Task <bool> SetConnectionString(string value) { _class = null; _wfsDataset = null; switch (ConfigTextStream.ExtractValue(value, "service").ToUpper()) { case "WMS": _type = SERVICE_TYPE.WMS; _connection = ConfigTextStream.ExtractValue(value, "wms"); _class = new WMSClass(this); break; case "WFS": _type = SERVICE_TYPE.WFS; _wfsDataset = new WFSDataset(this, ConfigTextStream.ExtractValue(value, "wfs")); break; case "WMS_WFS": _type = SERVICE_TYPE.WMS_WFS; _connection = ConfigTextStream.ExtractValue(value, "wms"); _class = new WMSClass(this); _wfsDataset = new WFSDataset(this, ConfigTextStream.ExtractValue(value, "wfs")); break; default: return(Task.FromResult(false)); } _connectionString = value; return(Task.FromResult(true)); }
public IEnumerable <ENUM_SERVICE_STATUS_PROCESS> EnumServicesStatusEx(SERVICE_TYPE serviceType, SERVICE_STATE_FLAGS serviceStateFlags) { int needed = 0; int servicesReturned = 0; uint resumeHandle = 0; if (NativeMethods.EnumServicesStatusEx( handle, SC_ENUM_PROCESS_INFO, serviceType, serviceStateFlags, IntPtr.Zero, 0, ref needed, ref servicesReturned, ref resumeHandle, null)) { throw new Win32Exception(0, $"Unexpected success in {nameof(ServiceControlManager)}.{nameof(EnumServicesStatusEx)}"); } // We expect an ERROR_MORE_DATA error as the buffer size passed in was zero, otherwise something strage is going on if (Marshal.GetLastWin32Error() != ERROR_MORE_DATA) { throw new Win32Exception(); } IntPtr bufferPtr = Marshal.AllocHGlobal(needed); var ptr = bufferPtr; try { if (!NativeMethods.EnumServicesStatusEx( handle, SC_ENUM_PROCESS_INFO, serviceType, serviceStateFlags, bufferPtr, needed, ref needed, ref servicesReturned, ref resumeHandle, null)) { throw new Win32Exception(); } for (int i = 0; i < servicesReturned; i++) { yield return((ENUM_SERVICE_STATUS_PROCESS)Marshal.PtrToStructure(ptr, typeof(ENUM_SERVICE_STATUS_PROCESS))); ptr += Marshal.SizeOf(typeof(ENUM_SERVICE_STATUS_PROCESS)); } } finally { Marshal.FreeHGlobal(bufferPtr); } }
public static bool GetLogStatusPerType(SERVICE_TYPE serviceType) { if (_serviceLocatorInstance) { return(_serviceLocatorInstance.GetLoggedStatusPerType(serviceType)); } return(false); }
public bool GetLoggedStatusPerType(SERVICE_TYPE serviceType) { if (loggedServiceStatusMap.ContainsKey(serviceType)) { return(logStatusPerServiceType[loggedServiceStatusMap[serviceType]].isLogged); } return(false); }
/// <summary> /// Dummy parsovanie /// </summary> /// <param name="req_s"> string predstavujuci sparsovany objekt</param> /// <returns></returns> public static Response ConvertToResponse(string req_s) { XElement tree = XElement.Parse(req_s); SERVICE_TYPE t = (SERVICE_TYPE)Enum.Parse(typeof(SERVICE_TYPE), tree.Attribute("type").Value); RESULT_CODE r = (RESULT_CODE)Enum.Parse(typeof(RESULT_CODE), tree.Attribute("code").Value); string data = tree.Value; return(new Response(t, data, r)); }
void OnServiceReady(SERVICE_TYPE serviceType, bool isConnectedSucc) { Debug.Log("OnServiceReady---------------------" + serviceType + "," + isConnectedSucc); if (serviceType == SERVICE_TYPE.SIX_DOF) { bool support6DOF = NxrViewer.Instance.GetNibiruService().IsSupport6DOF(); Debug.Log("Six Dof Support Status : " + (support6DOF ? 1 : 0)); } }
internal static extern bool EnumServicesStatus( IntPtr serviceControlObject, SERVICE_TYPE serviceType, SERVICE_STATE_FLAGS serviceState, IntPtr bufferPtr, Int32 bufferSize, ref Int32 bufferNeeded, ref Int32 servicesReturned, ref UInt32 resumeHandle);
internal static extern bool EnumServicesStatus( IntPtr hSCManager, SERVICE_TYPE dwServiceType, SERVICE_ACTIVE_STATE dwServiceState, IntPtr lpServices, int cbBufSize, out int pcbBytesNeeded, out int lpServicesReturned, ref int lpResumeHandle);
/// <summary> /// Vlozenie a zabalenie spravy podla zadaneho typu /// do urcenej struktury /// </summary> /// <param name="type"> typ requestu</param> /// <param name="data"> data requestu</param> /// <return>Message</return> public Message Wrap(MESSAGE_TYPE m, SERVICE_TYPE type, string data) { string message_content = ""; if (m == MESSAGE_TYPE.REQUEST) { message_content = new Request(type, data, DataSet.Instance().loged_user).ToString(); } return(new Message(m, message_content)); }
internal static extern bool EnumServicesStatusEx(IntPtr hSCManager, int infoLevel, SERVICE_TYPE serviceType, SERVICE_STATE_FLAGS serviceState, IntPtr services, Int32 bufSize, ref Int32 bytesNeeded, ref Int32 servicesReturned, ref UInt32 resumeHandle, string groupName );
private Service FindServiceOfType(SERVICE_TYPE type, ref Service[] services) { for (int i = 0; i < services.Length; ++i) { if (services[i].GetServiceType() == type) { return(services[i]); } } return(null); }
internal static extern bool EnumServicesStatusEx( IntPtr hSCManager, INFO_LEVEL infoLevel, SERVICE_TYPE dwServiceType, SERVICE_ACTIVE_STATE dwServiceState, IntPtr lpServices, int cbBufSize, out int pcbBytesNeeded, out int lpServicesReturned, ref int lpResumeHandle, string pszGroupName);
private static extern bool EnumServicesStatusEx( IntPtr hSCManager, int InfoLevel, SERVICE_TYPE dwServiceType, SERVICE_STATE_REQUEST dwServiceState, IntPtr lpServices, uint cbBufSize, out uint pcbBytesNeeded, out uint lpServicesReturned, ref uint lpResumeHandle, string pszGroupName);
public ServiceHandle CreateService(string name, string displayName, SERVICE_TYPE type, SERVICE_START_TYPE startType, SERVICE_ERROR_CONTROL errorControl, string binaryPath, string group, string accountName, string password) { int service; if ((service = Win32.CreateService(this, name, displayName, SERVICE_RIGHTS.SERVICE_ALL_ACCESS, type, startType, errorControl, binaryPath, group, 0, 0, accountName, password)) == 0) ThrowLastWin32Error(); return new ServiceHandle(service, true); }
public static extern bool ChangeServiceConfig( int Service, SERVICE_TYPE ServiceType, SERVICE_START_TYPE StartType, SERVICE_ERROR_CONTROL ErrorControl, string BinaryPath, string LoadOrderGroup, int TagID, int Dependencies, string StartName, string Password, string DisplayName );
internal static extern IntPtr CreateService( IntPtr hSCManager, string lpServiceName, string lpDisplayName, SERVICE_ACCESS dwDesiredAccess, SERVICE_TYPE dwServiceType, SERVICE_START_TYPE dwStartType, SERVICE_ERROR dwErrorControl, string lpBinaryPathName, string lpLoadOrderGroup, IntPtr lpdwTagId, string lpDependencies, string lpServiceStartName, string lpPassword);
public static extern int CreateService(int SCManager, string ServiceName, string DisplayName, SERVICE_RIGHTS DesiredAccess, SERVICE_TYPE ServiceType, SERVICE_START_TYPE StartType, SERVICE_ERROR_CONTROL ErrorControl, string BinaryPathName, string LoadOrderGroup, int TagID, int Dependencies, string ServiceStartName, string Password );
public ServiceHandle CreateService(string name, string displayName, SERVICE_TYPE type, SERVICE_START_TYPE startType, SERVICE_ERROR_CONTROL errorControl, string binaryPath, string group, string accountName, string password) { int service; if ((service = Win32.CreateService(this, name, displayName, SERVICE_RIGHTS.SERVICE_ALL_ACCESS, type, startType, errorControl, binaryPath, group, 0, 0, accountName, password)) == 0) { ThrowLastWin32Error(); } return(new ServiceHandle(service, true)); }
public IService CreateService( string serviceName, string displayName, SERVICE_ACCESS desiredAccess, SERVICE_TYPE serviceType, SERVICE_START_TYPE startType, SERVICE_ERROR_CONTROL errorControl, string binaryPathName, string loadOrderGroup, IntPtr tagId, ICollection <string> dependencies, string serviceStartName, string password) { string deps = (dependencies?.Any() ?? false) ? string.Join("\0", dependencies) : null; var serviceHandle = NativeMethods.CreateService( handle, serviceName, displayName, (uint)desiredAccess, (uint)serviceType, (uint)startType, (uint)errorControl, binaryPathName, loadOrderGroup, tagId, deps, serviceStartName, password ); if (serviceHandle == IntPtr.Zero) { throw new Win32Exception(); } return(new Service(serviceHandle)); }
/// <summary> /// Dummy parsovanie /// </summary> /// <param name="req_s"> string predstavujuci sparsovany objekt</param> /// <returns></returns> public static Request ConvertToRequest(string req_s) { try { XElement tree = XElement.Parse(req_s); SERVICE_TYPE t = (SERVICE_TYPE)Enum.Parse(typeof(SERVICE_TYPE), tree.Attribute("type").Value); XElement user_element = tree.Element("user"); string username = user_element.Attribute("username").Value; int hash = Int32.Parse(user_element.Attribute("password_hash").Value); Account user = new Account() { Is_LogedOn = false, password_hash = hash, user_name = username }; string data = tree.Element("data").Value; return(new Request(t, data, user)); } catch (Exception) { return(null); } }
void CreateNullService(SERVICE_TYPE serviceType) { switch (serviceType) { case SERVICE_TYPE.EXAMPLE: { serviceMaps[serviceType] = ExampleBaseService.GetNullService(GetLoggedStatusPerType(serviceType)); break; } case SERVICE_TYPE.NONE: { serviceMaps[serviceType] = GetNullService(); break; } case SERVICE_TYPE.TOTAL: { serviceMaps[serviceType] = GetServiceOfType(SERVICE_TYPE.NONE); break; } } }
public Service GetServiceOfType(SERVICE_TYPE serviceType) { if (Application.isPlaying) { Service currentService = null; //check if we have it already if (serviceMaps.TryGetValue(serviceType, out currentService)) { //if we do, check if its null if (currentService == null) { CreateNullService(serviceType); } } else { CreateNullService(serviceType); } return(serviceMaps[serviceType]); } return(null); }
private static ServiceController [] GetServices(string machineName, SERVICE_TYPE serviceType, string group) { IntPtr scHandle = IntPtr.Zero; IntPtr buffer = IntPtr.Zero; try { #if NET_2_0 scHandle = OpenServiceControlManager(machineName, SERVICE_MANAGER_RIGHTS.SC_MANAGER_ENUMERATE_SERVICE); #else scHandle = OpenServiceControlManager(machineName, SERVICE_MANAGER_RIGHTS.SC_MANAGER_ENUMERATE_SERVICE, true); #endif uint bufferSize = 0; uint bytesNeeded = 0; uint servicesReturned = 0; uint resumeHandle = 0; ServiceController [] services; while (true) { if (!EnumServicesStatusEx(scHandle, SC_ENUM_PROCESS_INFO, serviceType, SERVICE_STATE_REQUEST.SERVICE_STATE_ALL, buffer, bufferSize, out bytesNeeded, out servicesReturned, ref resumeHandle, group)) { int err = Marshal.GetLastWin32Error(); if (err == ERROR_MORE_DATA) { buffer = Marshal.AllocHGlobal((int)bytesNeeded); bufferSize = bytesNeeded; } else { throw new Win32Exception(err); } } else { int iPtr = buffer.ToInt32(); services = new ServiceController [servicesReturned]; for (int i = 0; i < servicesReturned; i++) { ENUM_SERVICE_STATUS_PROCESS serviceStatus = (ENUM_SERVICE_STATUS_PROCESS)Marshal.PtrToStructure( new IntPtr(iPtr), typeof(ENUM_SERVICE_STATUS_PROCESS)); // TODO: use internal ctor that takes displayname too services [i] = new ServiceController(serviceStatus.pServiceName, machineName); // move on to the next services iPtr += ENUM_SERVICE_STATUS_PROCESS.SizeOf; } // we're done, so exit the loop break; } } return(services); } finally { if (scHandle != IntPtr.Zero) { CloseServiceHandle(scHandle); } if (buffer != IntPtr.Zero) { Marshal.FreeHGlobal(buffer); } } }
public static extern SafeServiceHandle CreateService(SafeServiceHandle hSCManager, string lpServiceName, string lpDisplayName, SERVICE_ACCESS dwDesiredAccess, SERVICE_TYPE dwServiceType, ServiceStartType dwStartType, SERVICE_ERROR dwErrorControl, string lpBinaryPathName, string lpLoadOrderGroup, IntPtr lpdwTagId, char[] lpDependencies, string lpServiceStartName, string lpPassword);
public Response(SERVICE_TYPE type, string data, RESULT_CODE r) { this.type = type; this.data = data; this.code = r; }
public static extern IntPtr CreateService(IntPtr SC_HANDLE, string lpSvcName, string lpDisplayName, SERVICE_DESIRED_ACCESS dwDesiredAccess, SERVICE_TYPE dwServiceType, START_TYPE dwStartType, ERROR_CONTROL_TYPE dwErrorControl, string lpPathName, string lpLoadOrderGroup, int lpdwTagId, string lpDependencies, string lpServiceStartName, string lpPassword);
public T GetServiceOfType <T>(SERVICE_TYPE serviceType) where T : Service { return((T)GetServiceOfType(serviceType)); }
public ServiceHandle CreateService(string name, string displayName, SERVICE_TYPE type, SERVICE_START_TYPE startType, string binaryPath) { return this.CreateService(name, displayName, type, startType, SERVICE_ERROR_CONTROL.Ignore, binaryPath, null, null, null); }
public Request(SERVICE_TYPE type, string data, Account user) { this.type = type; this.data = data; this.user = user; }
private static ServiceController [] GetServices (string machineName, SERVICE_TYPE serviceType, string group) { IntPtr scHandle = IntPtr.Zero; IntPtr buffer = IntPtr.Zero; try { #if NET_2_0 scHandle = OpenServiceControlManager (machineName, SERVICE_MANAGER_RIGHTS.SC_MANAGER_ENUMERATE_SERVICE); #else scHandle = OpenServiceControlManager (machineName, SERVICE_MANAGER_RIGHTS.SC_MANAGER_ENUMERATE_SERVICE, true); #endif uint bufferSize = 0; uint bytesNeeded = 0; uint servicesReturned = 0; uint resumeHandle = 0; ServiceController [] services; while (true) { if (!EnumServicesStatusEx (scHandle, SC_ENUM_PROCESS_INFO, serviceType, SERVICE_STATE_REQUEST.SERVICE_STATE_ALL, buffer, bufferSize, out bytesNeeded, out servicesReturned, ref resumeHandle, group)) { int err = Marshal.GetLastWin32Error (); if (err == ERROR_MORE_DATA) { buffer = Marshal.AllocHGlobal ((int) bytesNeeded); bufferSize = bytesNeeded; } else { throw new Win32Exception (err); } } else { int iPtr = buffer.ToInt32 (); services = new ServiceController [servicesReturned]; for (int i = 0; i < servicesReturned; i++) { ENUM_SERVICE_STATUS_PROCESS serviceStatus = (ENUM_SERVICE_STATUS_PROCESS) Marshal.PtrToStructure ( new IntPtr (iPtr), typeof (ENUM_SERVICE_STATUS_PROCESS)); // TODO: use internal ctor that takes displayname too services [i] = new ServiceController (serviceStatus.pServiceName, machineName); // move on to the next services iPtr += ENUM_SERVICE_STATUS_PROCESS.SizeOf; } // we're done, so exit the loop break; } } return services; } finally { if (scHandle != IntPtr.Zero) CloseServiceHandle (scHandle); if (buffer != IntPtr.Zero) Marshal.FreeHGlobal (buffer); } }
private static extern bool EnumServicesStatusEx ( IntPtr hSCManager, int InfoLevel, SERVICE_TYPE dwServiceType, SERVICE_STATE_REQUEST dwServiceState, IntPtr lpServices, uint cbBufSize, out uint pcbBytesNeeded, out uint lpServicesReturned, ref uint lpResumeHandle, string pszGroupName);
internal static extern bool ChangeServiceConfig(SafeServiceHandle service, SERVICE_TYPE serviceType, SERVICE_STARTTYPE startType, SERVICE_ERRORCONTROL errorControl, String binaryPathName, String loadOrderGroup, IntPtr pdwTagId, String dependencies, String serviceStartName, String password, String displayName);
public ServiceHandle CreateService(string name, string displayName, SERVICE_TYPE type, SERVICE_START_TYPE startType, string binaryPath) { return(this.CreateService(name, displayName, type, startType, SERVICE_ERROR_CONTROL.Ignore, binaryPath, null, null, null)); }