slpd_win32.c

SLP协议在linux下的实现。此版本为1.2.1版。官方网站为www.openslp.org

            alarmtime = curtime + SLPD_AGE_INTERVAL;
        }

    } /* End of main loop */

    /* Got SIGTERM */
    HandleSigTerm();

    cleanup_winsock:
    WSACleanup();

    cleanup: 
    ;
} 

/*==========================================================================*/
BOOL WINAPI ControlHandler ( DWORD dwCtrlType ) 
/*                                                                          */
/*  PURPOSE: Handled console control events                                 */
/*                                                                          */
/*  PARAMETERS:                                                             */
/*    dwCtrlType - type of control event                                    */
/*                                                                          */
/*  RETURN VALUE:                                                           */
/*    True - handled                                                        */
/*    False - unhandled                                                     */
/*                                                                          */
/*==========================================================================*/
{
    switch(dwCtrlType)
    {
    case CTRL_BREAK_EVENT:  /* use Ctrl+C or Ctrl+Break to simulate    */
    case CTRL_C_EVENT:      /* SERVICE_CONTROL_STOP in debug mode    */
        printf("Stopping %s.\n", G_SERVICEDISPLAYNAME); 
        ServiceStop(); 
        return TRUE; 
        break; 

    } 
    return FALSE; 
} 


/*==========================================================================*/
VOID WINAPI ServiceCtrl(DWORD dwCtrlCode) 
/*                                                                          */
/*  PURPOSE: This function is called by the SCM whenever                    */
/*           ControlService() is called on this service.                    */
/*                                                                          */
/*  PARAMETERS:                                                             */
/*    dwCtrlCode - type of control requested                                */
/*                                                                          */
/*  RETURN VALUE:                                                           */
/*    none                                                                  */
/*                                                                          */
/*==========================================================================*/
{
    /* Handle the requested control code.    */
    /*    */

    switch(dwCtrlCode)
    {
    /* Stop the service.    */
    case SERVICE_CONTROL_STOP: 
        ReportStatusToSCMgr(SERVICE_STOP_PENDING, NO_ERROR, 0); 
        ServiceStop(); 
        return; 

        /* Update the service status.    */
    case SERVICE_CONTROL_INTERROGATE: 
        break; 

        /* invalid control code    */
    default: 
        break; 

    } 

    ReportStatusToSCMgr(ssStatus.dwCurrentState, NO_ERROR, 0); 
} 


/*==========================================================================*/
void WINAPI SLPDServiceMain(DWORD argc, LPTSTR *argv) 
/*==========================================================================*/
{

    /* register our service control handler:    */
    sshStatusHandle = RegisterServiceCtrlHandler( G_SERVICENAME, ServiceCtrl); 

    if(sshStatusHandle != 0)
    {
        /* SERVICE_STATUS members that don't change    */
        ssStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS; 
        ssStatus.dwServiceSpecificExitCode = 0; 


        /* report the status to the service control manager.    */
        if(ReportStatusToSCMgr(SERVICE_START_PENDING, /* service state    */
                               NO_ERROR,              /* exit code    */
                               3000))                 /* wait hint    */
        {
            ServiceStart(argc, argv); 
        }
    }


    /* try to report the stopped status to the service control manager.    */

    if(sshStatusHandle)
        (void)ReportStatusToSCMgr(SERVICE_STOPPED, 
                                  0, 
                                  0);


} 


/*--------------------------------------------------------------------------*/
void SLPDCmdInstallService(int automatic) 
/*--------------------------------------------------------------------------*/
{
    SC_HANDLE   schService; 
    SC_HANDLE   schSCManager; 

    DWORD start_type;
    TCHAR szPath[512]; 

    if(GetModuleFileName( NULL, szPath, 512 ) == 0)
    {
        printf("Unable to install %s - %s\n", 
               G_SERVICEDISPLAYNAME, 
               GetLastErrorText(szErr, 256)); 
        return; 
    }

    if(automatic)
    {
      start_type = SERVICE_AUTO_START;
    }
    else
    {
      start_type = SERVICE_DEMAND_START;
    } 

    schSCManager = OpenSCManager(
                                NULL,                   /* machine (NULL == local)    */
                                NULL,                   /* database (NULL == default)    */
                                SC_MANAGER_ALL_ACCESS); /* access required    */

    if(schSCManager)
    {
        schService = CreateService(
                                  schSCManager,               /* SCManager database    */
                                  G_SERVICENAME,        /* name of service    */
                                  G_SERVICEDISPLAYNAME, /* name to display    */
                                  SERVICE_ALL_ACCESS,         /* desired access    */
                                  SERVICE_WIN32_OWN_PROCESS,  /* service type    */
                                  start_type,       			  /* start type    */
                                  SERVICE_ERROR_NORMAL,       /* error control type    */
                                  szPath,                     /* service's binary    */
                                  NULL,                       /* no load ordering group    */
                                  NULL,                       /* no tag identifier    */
                                  "",       /* dependencies    */
                                  NULL,                       /* LocalSystem account    */
                                  NULL);                      /* no password    */

        if(schService)
        {
            printf("%s installed.\n", G_SERVICEDISPLAYNAME ); 
            CloseServiceHandle(schService); 
        }
        else
        {
            printf("CreateService failed - %s\n", GetLastErrorText(szErr, 256)); 
        } 

        CloseServiceHandle(schSCManager); 
    }
    else
        printf("OpenSCManager failed - %s\n", GetLastErrorText(szErr,256)); 
} 

static void SLPDHlpStopService(SC_HANDLE schService)
{
	/* try to stop the service    */
	if(ControlService(schService, SERVICE_CONTROL_STOP, &ssStatus))
	{
		printf("Stopping %s.", G_SERVICEDISPLAYNAME);
		Sleep(1000);
      
		while(QueryServiceStatus(schService, &ssStatus))
		{
			if(ssStatus.dwCurrentState == SERVICE_STOP_PENDING)
			{
				printf(".");
				Sleep(1000);
			}
			else
				break; 
		} 
      
		if(ssStatus.dwCurrentState == SERVICE_STOPPED)
			printf("\n%s stopped.\n", G_SERVICEDISPLAYNAME);
		else
			printf("\n%s failed to stop.\n", G_SERVICEDISPLAYNAME); 
	}
}
 
/*--------------------------------------------------------------------------*/
void SLPDCmdRemoveService() 
/*--------------------------------------------------------------------------*/
{
    SC_HANDLE schService; 
    SC_HANDLE schSCManager; 

    schSCManager = OpenSCManager(
                                NULL,                   /* machine (NULL == local)    */
                                NULL,                   /* database (NULL == default)    */
                                SC_MANAGER_ALL_ACCESS); /* access required    */
    if(schSCManager)
    {
        schService = OpenService(schSCManager, G_SERVICENAME, SERVICE_ALL_ACCESS); 

        if(schService)
        {
				SLPDHlpStopService(schService);

				/* now remove the service    */
            if(DeleteService(schService))
                printf("%s removed.\n", G_SERVICEDISPLAYNAME );
            else
                printf("DeleteService failed - %s\n", GetLastErrorText(szErr,256)); 


            CloseServiceHandle(schService); 
        }
        else
            printf("OpenService failed - %s\n", GetLastErrorText(szErr,256)); 

        CloseServiceHandle(schSCManager); 
    }
    else
        printf("OpenSCManager failed - %s\n", GetLastErrorText(szErr,256)); 
} 

/*--------------------------------------------------------------------------*/
void SLPDCmdStartService()
/*--------------------------------------------------------------------------*/
{
	 SC_HANDLE schService; 
	 SC_HANDLE schSCManager; 

	 schSCManager = OpenSCManager(
	 									  NULL,                   /* machine (NULL == local)    */
	 									  NULL,                   /* database (NULL == default) */
	 									  SC_MANAGER_ALL_ACCESS); /* access required    		  */
	 if(schSCManager)
	 {
	 	  schService = OpenService(schSCManager, G_SERVICENAME, SERVICE_ALL_ACCESS); 

	 	  if(schService)
	 	  {
	 			if( !StartService(schService, 0, NULL))
	 			{
	 				 printf("OpenService failed - %s\n", GetLastErrorText(szErr,256)); 
	 			}
	 			CloseServiceHandle(schService); 
	 	  }
	 	  else
	 	  {
	 	  		printf("OpenService failed - %s\n", GetLastErrorText(szErr,256)); 
	 	  }
	 	  CloseServiceHandle(schSCManager); 
	 }
	 else
	 {
	 	  printf("OpenSCManager failed - %s\n", GetLastErrorText(szErr,256)); 
	 }
}

/*--------------------------------------------------------------------------*/
void SLPDCmdStopService()
/*--------------------------------------------------------------------------*/
{
	 SC_HANDLE schService; 
	 SC_HANDLE schSCManager; 

	 schSCManager = OpenSCManager(
	 									  NULL,                   /* machine (NULL == local)    */
	 									  NULL,                   /* database (NULL == default) */
	 									  SC_MANAGER_ALL_ACCESS); /* access required    		  */
	 if(schSCManager)
	 {
	 	  schService = OpenService(schSCManager, G_SERVICENAME, SERVICE_ALL_ACCESS); 

	 	  if(schService)
	 	  {
	 			SLPDHlpStopService(schService);
	 			CloseServiceHandle(schService); 
	 	  }
	 	  else
	 	  {
	 			printf("OpenService failed - %s\n", GetLastErrorText(szErr,256)); 
	 	  }
	 	  CloseServiceHandle(schSCManager); 
	 }
	 else
	 {
	 	  printf("OpenSCManager failed - %s\n", GetLastErrorText(szErr,256)); 
	 }
}

/*--------------------------------------------------------------------------*/
void SLPDCmdDebugService(int argc, char ** argv) 
/*--------------------------------------------------------------------------*/
{
    printf("Debugging %s.\n", G_SERVICEDISPLAYNAME); 

    SetConsoleCtrlHandler( ControlHandler, TRUE ); 
    ServiceStart( argc, argv ); 
}

/*==========================================================================*/
void __cdecl main(int argc, char **argv) 
/*==========================================================================*/
{
    SERVICE_TABLE_ENTRY dispatchTable[] = 
    { 
        { G_SERVICENAME, (LPSERVICE_MAIN_FUNCTION)SLPDServiceMain}, 
        { NULL, NULL} 
    }; 

    /*------------------------*/
    /* Parse the command line */
    /*------------------------*/
    if(SLPDParseCommandLine(argc,argv))
    {
        SLPDFatal("Invalid command line\n");
    }

    switch(G_SlpdCommandLine.action)
    {
    case SLPD_DEBUG:
        SLPDCmdDebugService(argc, argv);
        break;
    case SLPD_INSTALL:
        SLPDCmdInstallService(G_SlpdCommandLine.autostart);
        break;
    case SLPD_REMOVE:
        SLPDCmdRemoveService();
        break;
    case SLPD_START:
        SLPDCmdStartService();
		  break;
    case SLPD_STOP:
        SLPDCmdStopService();
        break;
    default:
        SLPDPrintUsage();
        StartServiceCtrlDispatcher(dispatchTable);

        break;
    } 
}