Accedere e modificare le proprietà di un Servizio (Storico)

Sabrina C. — Mon, 24 Mar 2008 16:51:26 GMT

Fra le cose che succedono ad un programmatore, la presa in carico di un progetto sviluppato da un'altro programmatore è forse una delle più difficili, soprattutto se questo programmatore, benché bravissimo ad ottenere risultati, ha utilizzato per ottenerli una serie di sotterfugi tali per cui, chi prende in carico il suo progetto si trova a non essere in grado neppure di ricompilarlo. In un occasione di questo tipo uno dei problemi che ho riscontrato è stato l'uso da parte di questo collega di una DLL non COM, non managed (in parole povere NON), per ovviare alla mancanza all'interno del framework di una classe che ci permetta di manipolare la configurazione dei servizi di una macchina.

Ovviamente, manipolare la configurazione di un servizio non fa parte delle cose che si fanno ogni mattina nelle nostre applicazioni .NET, in questo caso, l'applicazione è una Console per la configurazione di due servizi che è destinata all'uso esclusivo dei system administrator. Essendo questi signori molto pigri è necessario per noi sviluppatori fargli fare tutto da una singola form, sennò si confondono (Se lo legge il sistemaio mi sistema per le feste e mi impedisce anche l'uso della tastiera :P).

L'operazione che la DLL sconosciuta faceva consisteva nella modifica del flag di Startup del servizio, da Manuale ad Automatico e viceversa. Dato che questa DLL non funziona sul mio PC e non so se sia dovuto al fatto che è un XP al posto di un 2000 o 2003 server, oppure se è dovuto al framework 2.0 oppure semplicemente perché la DLL è rovinata, ho esposto la mia disperazione al forum, e Mario Raccagni che ringrazio di cuore, mi ha fornito una classe VB.NET che faceva qualcosa di simile utilizzando le API di windows.

Visto che questo è un problema strano ma potrebbe accadere ad altri, ho pensato di rendere pubblica la classe che ho generato che al momento modifica solo il flag a me necessario, ma volendo, potrebbe essere utilizzata per fare diversi tipi di manipolazioni su un servizio installato.

#region Using directives

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;

#endregion

namespace ForYou.F2PConsole
{
    ///
    /// Descrizione della classe: 
    ///
    ///
    ///
    public static class ServiceConfigManager
    {
        #region Variabili private

        ///
        /// Nome della classe usato per debug nella generazione delle eccezioni
        ///
        ///
        ///
        private readonly static string mClassNameS = System.Reflection.MethodBase.GetCurrentMethod().ReflectedType.Name;

        [StructLayout(LayoutKind.Sequential)]
        private struct QUERY_SERVICE_CONFIG
        {
            public int dwServiceType;
            public int dwStartType;
            public int dwErrorControl;
            public IntPtr pBinaryPathName;
            public IntPtr pLoadOrderGroup;
            public int dwTagId;
            public IntPtr pDependencies;
            public IntPtr pServiceStartName;
            public IntPtr pDisplayName;
        } // QUERY_SERVICE_CONFIG

        private const int SC_MANAGER_CONNECT = 1;
        private const int SERVICE_QUERY_CONFIG = 1;
        private const int SERVICE_CHANGE_CONFIG = 2;
        private const int SERVICE_INTERACTIVE_PROCESS = 0x100;
        private const int ERROR_INSUFFICIENT_BUFFER = 122;
        private const uint SERVICE_NO_CHANGE = 0xFFFFFFFF;

        /// 
        /// Queries the service config.
        /// 
        /// The h service.
        /// The p buffer.
        /// Size of the cb buf.
        /// The PCB bytes needed.
        /// 
    [DllImport("advapi32.dll", EntryPoint="QueryServiceConfigW", SetLastError=true, 
           CharSet=CharSet.Unicode, ExactSpelling=true, 
           CallingConvention=CallingConvention.StdCall)]
           private static extern bool QueryServiceConfig(IntPtr hService,
       IntPtr pBuffer, int cbBufSize, out int pcbBytesNeeded);

           /// 
           /// Changes the service config.
           /// 
           /// The h service.
           /// Type of the dw service.
           /// Start type of the dw.
           /// The dw error control.
           /// Name of the p binary path.
           /// The p load order group.
           /// The PDW tag id.
           /// The p dependencies.
           /// Start name of the p service.
           /// The p password.
           /// Name of the p display.
           /// 
    [DllImport("advapi32.dll", EntryPoint="ChangeServiceConfigW", SetLastError=true, 
           CharSet=CharSet.Unicode, ExactSpelling=true, 
           CallingConvention=CallingConvention.StdCall)]
        private static extern bool ChangeServiceConfig(IntPtr hService, int dwServiceType,
        int dwStartType, int dwErrorControl, IntPtr pBinaryPathName, IntPtr pLoadOrderGroup,
        int pdwTagId, IntPtr pDependencies, IntPtr pServiceStartName, IntPtr pPassword, IntPtr pDisplayName);

        /// 
        /// Opens the SC manager.
        /// 
        /// Name of the s machine.
        /// Name of the s database.
        /// The dw desired action.
        /// 
    [DllImport("advapi32.dll", EntryPoint="OpenSCManagerW", SetLastError=true,
            CharSet=CharSet.Unicode, ExactSpelling=true, CallingConvention=CallingConvention.StdCall)] 
       private static extern IntPtr OpenSCManager(string sMachineName, string sDatabaseName, int dwDesiredAction );

        /// 
        /// Opens the service.
        /// 
        /// The h SCM.
        /// Name of the s service.
        /// The dw desired action.
        /// 
    [DllImport("advapi32.dll", EntryPoint="OpenServiceW", SetLastError=true, 
           CharSet=CharSet.Unicode, ExactSpelling=true, CallingConvention=CallingConvention.StdCall)]
        private static extern IntPtr OpenService(IntPtr hSCM, string sServiceName, int dwDesiredAction);

        /// 
        /// Closes the service handle.
        /// 
        /// The h SC handle.
        /// 
    [DllImport("advapi32.dll", EntryPoint="CloseServiceHandle", SetLastError=true,
           ExactSpelling=true, CallingConvention=CallingConvention.StdCall)]
        private static extern bool CloseServiceHandle(IntPtr hSCHandle);

        #endregion

        /// 
        /// Legge la configurazione di avvio di un servizio
        /// 
        /// Name of the p service.
        /// 
        public static int GetStartConfig(  string pServiceName )
        {
            try
            {
                int ret = 0;
                IntPtr hScm = OpenSCManager(null, null, SC_MANAGER_CONNECT);
                if (hScm.Equals(0))
                {
                    throw new ApplicationException("OpenSCManager() failed with error " + Marshal.GetLastWin32Error());
                }

                IntPtr hService = OpenService(hScm, pServiceName, SERVICE_QUERY_CONFIG | SERVICE_CHANGE_CONFIG);
                if( hService.Equals(0) )
                {
                    throw new ApplicationException("OpenService() failed with error " + Marshal.GetLastWin32Error());
                }
                IntPtr pBuffer=new IntPtr();
                int cbServiceConfig = 0;
                bool fResult = QueryServiceConfig(hService, pBuffer, cbServiceConfig, out cbServiceConfig);
                if (Marshal.GetLastWin32Error() != ERROR_INSUFFICIENT_BUFFER)
                {
                    throw new ApplicationException("QueryServiceConfig() failed with error " + Marshal.GetLastWin32Error());
                }

                pBuffer = Marshal.AllocHGlobal(cbServiceConfig);
                fResult = QueryServiceConfig(hService, pBuffer, cbServiceConfig, out cbServiceConfig);
                if (!fResult)
                {
                    throw new ApplicationException("QueryServiceConfig() failed with error " + Marshal.GetLastWin32Error());
                }
                QUERY_SERVICE_CONFIG serviceConfig = 
                    (QUERY_SERVICE_CONFIG)Marshal.PtrToStructure(pBuffer, typeof(QUERY_SERVICE_CONFIG));
                ret = serviceConfig.dwStartType;

                if (!pBuffer.Equals(0))
                {
                    Marshal.FreeHGlobal(pBuffer);
                } // if
                CloseServiceHandle(hService);
                CloseServiceHandle(hScm);

                return (ret);
            }
            catch (Exception ex)
            {
                throw new ApplicationException(" " + mClassNameS + "."
                    + System.Reflection.MethodBase.GetCurrentMethod().Name, ex);
            }
        }

        /// 
        /// Attiva l'avvio automatico di un servizio
        /// 
        /// Name of the p service.
        /// 
        public static bool SetStartConfigAutomatic(string pServiceName)
        {
            try
            {
                return( SetStartConfig(pServiceName, 2));
            }
            catch (Exception ex)
            {
                throw new ApplicationException(" " + mClassNameS + "."
                    + System.Reflection.MethodBase.GetCurrentMethod().Name, ex);
            }
        }

        /// 
        /// Attiva l'avvio manuale per un servizio
        /// 
        /// Name of the p service.
        /// 
        public static bool SetStartConfigManual(string pServiceName)
        {
            try
            {
                return( SetStartConfig(pServiceName, 3));
            }
            catch (Exception ex)
            {
                throw new ApplicationException(" " + mClassNameS + "."
                    + System.Reflection.MethodBase.GetCurrentMethod().Name, ex);
            }
        }

        /// 
        /// Disattiva l'avvio di un servizio
        /// 
        /// Name of the p service.
        /// 
        public static bool SetStartConfigDisable(string pServiceName)
        {
            try
            {
                return( SetStartConfig(pServiceName, 4));
            }
            catch (Exception ex)
            {
                throw new ApplicationException(" " + mClassNameS + "."
                    + System.Reflection.MethodBase.GetCurrentMethod().Name, ex);
            }

        }

        /// 
        /// Predispone la modalità di avvio di un servizio
        /// 
        /// Name of the p service.
        /// The p value.
        /// 
        private static bool SetStartConfig(string pServiceName, int pValue)
        {
            try
            {
                IntPtr hScm = OpenSCManager(null, null, SC_MANAGER_CONNECT);
                if (hScm.Equals(0))
                {
                    throw new ApplicationException("OpenSCManager() failed with error " + Marshal.GetLastWin32Error());
                }

                IntPtr hService = OpenService(hScm, pServiceName, SERVICE_QUERY_CONFIG | SERVICE_CHANGE_CONFIG);
                if (hService.Equals(0))
                {
                    throw new ApplicationException("OpenService() failed with error " + Marshal.GetLastWin32Error());
                }

                IntPtr pBuffer = new IntPtr();
                int cbServiceConfig = 0;
                bool fResult = QueryServiceConfig(hService, pBuffer, cbServiceConfig, out cbServiceConfig);
                if (Marshal.GetLastWin32Error() != ERROR_INSUFFICIENT_BUFFER)
                {
                    throw new ApplicationException("QueryServiceConfig() failed with error " + Marshal.GetLastWin32Error());
                }

                pBuffer = Marshal.AllocHGlobal(cbServiceConfig);
                fResult = QueryServiceConfig(hService, pBuffer, cbServiceConfig, out cbServiceConfig);
                if (!fResult)
                {
                    throw new ApplicationException("QueryServiceConfig() failed with error " + Marshal.GetLastWin32Error());
                }
                QUERY_SERVICE_CONFIG serviceConfig =
                    (QUERY_SERVICE_CONFIG)Marshal.PtrToStructure(pBuffer, typeof(QUERY_SERVICE_CONFIG));

                fResult = ChangeServiceConfig(hService, serviceConfig.dwServiceType, pValue, serviceConfig.dwErrorControl,
                    serviceConfig.pBinaryPathName, serviceConfig.pLoadOrderGroup, serviceConfig.dwTagId,
                    serviceConfig.pDependencies, serviceConfig.pServiceStartName, IntPtr.Zero, serviceConfig.pDisplayName);

                if (!pBuffer.Equals(0))
                {
                    Marshal.FreeHGlobal(pBuffer);
                } // if
                CloseServiceHandle(hService);
                CloseServiceHandle(hScm);
                return(fResult);
            }
            catch (Exception ex)
            {
                throw new ApplicationException(" " + mClassNameS + "."
                    + System.Reflection.MethodBase.GetCurrentMethod().Name, ex);
            }
        }

    }
}

Tags: servizi, configurazione, Dllimport , classi

Errore 193 0xc1 Avviando un servizio (Storico)

Sabrina C. — Mon, 24 Mar 2008 08:10:42 GMT

Mi ci sono imbattuta nelle mie prove e test per la presa in carico di un progetto non mio, una delle cose che ho fatto per portare il progetto dal codice scritto in modo "selvaggio" (senza commenti e con il minimo uso dell'OOP) agli standard interni che ci siamo dati in azienda, è quello di togliere tutto il codice dall'interno del progetto del servizio lasciandovi solo gli entry point, in questo modo, le funzionalità svolte dal servizio possono essere testate utilizzando una applicazione windows normale oppure gli UnitTest, e per testare il servizio non è necessario fare alcun tipo di debug, visto che fa solo uno start e instanzia un oggetto oppure uno stop e cestina l'oggetto.

Mentre facevo questo, semplicemente buttando via il vecchio servizio e generandone uno equivalente, mi sono imbattuta in questo strano errore di avvio, questo errore, è causato dal fatto che, nella mia furia estrattiva, avevo tolto dal progetto del servizio la classe contenente il project installer mettendola su una diversa DLL, credendo erroneamente che l'installer prendesse l'assembly del mio servizio, di cui gli davo il nome e lo installasse indipendentemente da dove questo fosse situato. Invece, a ragione, l'installer utilizza l'assembly dove si trova e non uno esterno, pertanto, estrarre il codice va bene, ma l'installer è necessario resti dentro l'eseguibile del progetto altrimenti Errore 193 0xc1.

Oltre a questo, avevo commesso un'altro errore, infatti, il nome della classe del servizio non è uguale al nome del servizio (questa è stata una scelta effettuata alle origini su cui non indago) per cui, avendo dato all'installer un nome mentre il servizio ne aveva uno diverso, di qui l'errore 193 0xc1.

Perché bloggare questa sciocchezza ed espormi al generale ludibrio per la mia pochezza di programmatore?
Perché su google ho trovato 10000 richieste su cosa potesse essere questo errore, e nessuna risposta. Quindi spero che qualcuno incappando nel mio stesso errore possa beneficiarne.

(2006)

Tags:servizi,errori,avvio,installer,classi

Servizi Windows

Accedere e modificare le proprietà di un Servizio (Storico)

Errore 193 0xc1 Avviando un servizio (Storico)