mitk::ExampleDataStructureWriterService::ExampleDataStructureWriterService()
: AbstractFileWriter(mitk::ExampleDataStructure::GetStaticNameOfClass(),
CustomMimeType(mitk::ExampleIOMimeTypes::EXAMPLE_MIMETYPE()),
"Default writer for the example data structure")
{
RegisterService();
}
// CreateProxyRegistrationForRealService() checks to see if the given port is currently
// in use, and if so, advertises the specified service as present on that port.
// This is useful for advertising existing real services (Personal Web Sharing, Personal
// File Sharing, etc.) that currently don't register with mDNS Service Discovery themselves.
static DNSServiceErrorType CreateProxyRegistrationForRealService(RegisteredService *rs,
const char *servicetype, UInt16 PortAsNumber, const char txtinfo[])
{
mDNSOpaque16 OpaquePort = mDNSOpaque16fromIntVal(PortAsNumber);
InetAddress ia;
TBind bindReq;
OSStatus err;
TEndpointInfo endpointinfo;
EndpointRef ep = OTOpenEndpoint(OTCreateConfiguration(kTCPName), 0, &endpointinfo, &err);
if (!ep || err) { printf("OTOpenEndpoint (CreateProxyRegistrationForRealService) failed %d", err); return(err); }
ia.fAddressType = AF_INET;
ia.fPort = OpaquePort.NotAnInteger;
ia.fHost = 0;
bindReq.addr.maxlen = sizeof(ia);
bindReq.addr.len = sizeof(ia);
bindReq.addr.buf = (UInt8*)&ia;
bindReq.qlen = 0;
err = OTBind(ep, &bindReq, NULL);
if (err == kOTBadAddressErr)
err = RegisterService(rs, OpaquePort, "", servicetype, "local.", txtinfo);
else if (err)
printf("OTBind failed %d", err);
OTCloseProvider(ep);
return(err);
}
mitk::LegacyFileWriterService::LegacyFileWriterService(mitk::FileWriter::Pointer legacyWriter,
const std::string &description)
: AbstractFileWriter(legacyWriter->GetSupportedBaseData()), m_LegacyWriter(legacyWriter)
{
this->SetMimeTypePrefix(IOMimeTypes::DEFAULT_BASE_NAME() + ".legacy.");
this->SetDescription(description);
CustomMimeType customMimeType;
std::vector<std::string> extensions = legacyWriter->GetPossibleFileExtensions();
for (auto ext = extensions.begin(); ext != extensions.end(); ++ext)
{
if (ext->empty())
continue;
std::string extension = *ext;
if (extension.size() > 1 && extension[0] == '*')
{
// remove "*"
extension = extension.substr(1);
}
if (extension.size() > 1 && extension[0] == '.')
{
// remove "."
extension = extension.substr(1);
}
std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
customMimeType.AddExtension(extension);
}
this->SetMimeType(customMimeType);
m_ServiceRegistration = RegisterService();
}
UPnpCDS::UPnpCDS( UPnpDevice *pDevice, const QString &sSharePath ) : Eventing( "UPnpCDS", "CDS_Event" )
{
m_extensions.setAutoDelete( true );
m_root.m_eType = OT_Container;
m_root.m_sId = "0";
m_root.m_sParentId = "-1";
m_root.m_sTitle = "MythTv";
m_root.m_sClass = "object.container";
m_root.m_bRestricted= true;
m_root.m_bSearchable= true;
AddVariable( new StateVariable< QString >( "TransferIDs" , true ) );
AddVariable( new StateVariable< QString >( "ContainerUpdateIDs", true ) );
AddVariable( new StateVariable< unsigned short >( "SystemUpdateID" , true ) );
SetValue< unsigned short >( "SystemUpdateID", 1 );
QString sUPnpDescPath = UPnp::g_pConfig->GetValue( "UPnP/DescXmlPath", sSharePath );
m_sSharePath = sSharePath;
m_sServiceDescFileName = sUPnpDescPath + "CDS_scpd.xml";
m_sControlUrl = "/CDS_Control";
// Add our Service Definition to the device.
RegisterService( pDevice );
}
// CreateProxyRegistrationForRealService() checks to see if the given port is currently
// in use, and if so, advertises the specified service as present on that port.
// This is useful for advertising existing real services (Personal Web Sharing, Personal
// File Sharing, etc.) that currently don't register with mDNS Service Discovery themselves.
mDNSlocal OSStatus CreateProxyRegistrationForRealService(mDNS *m, UInt16 PortAsNumber, const char txtinfo[],
const char *servicetype, ServiceRecordSet *recordset)
{
InetAddress ia;
TBind bindReq;
OSStatus err;
TEndpointInfo endpointinfo;
EndpointRef ep = OTOpenEndpoint(OTCreateConfiguration(kTCPName), 0, &endpointinfo, &err);
if (!ep || err) { printf("OTOpenEndpoint (CreateProxyRegistrationForRealService) failed %d", err); return(err); }
ia.fAddressType = AF_INET;
ia.fPort = mDNSOpaque16fromIntVal(PortAsNumber).NotAnInteger;
ia.fHost = 0;
bindReq.addr.maxlen = sizeof(ia);
bindReq.addr.len = sizeof(ia);
bindReq.addr.buf = (UInt8*)&ia;
bindReq.qlen = 0;
err = OTBind(ep, &bindReq, NULL);
if (err == kOTBadAddressErr)
RegisterService(m, recordset, PortAsNumber, txtinfo, &m->nicelabel, servicetype, "local.");
else if (err)
debugf("OTBind failed %d", err);
OTCloseProvider(ep);
return(noErr);
}
UPnpCMGR::UPnpCMGR ( UPnpDevice *pDevice,
const QString &sSharePath,
const QString &sSourceProtocols,
const QString &sSinkProtocols )
: Eventing( "UPnpCMGR", "CMGR_Event", sSharePath)
{
AddVariable( new StateVariable< QString >( "SourceProtocolInfo" , true ) );
AddVariable( new StateVariable< QString >( "SinkProtocolInfo" , true ) );
AddVariable( new StateVariable< QString >( "CurrentConnectionIDs", true ) );
AddVariable( new StateVariable< QString >( "FeatureList" , true ) );
SetValue< QString >( "CurrentConnectionIDs", "0" );
SetValue< QString >( "SourceProtocolInfo" , sSourceProtocols );
SetValue< QString >( "SinkProtocolInfo" , sSinkProtocols );
SetValue< QString >( "FeatureList" , "" );
QString sUPnpDescPath = UPnp::GetConfiguration()->GetValue( "UPnP/DescXmlPath",
m_sSharePath );
m_sServiceDescFileName = sUPnpDescPath + "CMGR_scpd.xml";
m_sControlUrl = "/CMGR_Control";
// Add our Service Definition to the device.
RegisterService( pDevice );
}
void CMainApp::RunService()
{
SetServiceInfo(
(CHAR*)CAppConfig::Instance().GetServiceName(),
(CHAR*)CAppConfig::Instance().GetServiceName());
RegisterService(g_nArgc, g_pszArgv);
}
// RegisterFakeServiceForTesting() simulates the effect of services being registered on
// dynamically-allocated port numbers. No real service exists on that port -- this is just for testing.
mDNSlocal void RegisterFakeServiceForTesting(mDNS *m, ServiceRecordSet *recordset, const char txtinfo[],
const char name[], const char type[], const char domain[])
{
static UInt16 NextPort = 0xF000;
domainlabel n;
MakeDomainLabelFromLiteralString(&n, name);
RegisterService(m, recordset, NextPort++, txtinfo, &n, type, domain);
}
/************************************************************
* main function for Windows
* Parse command line arguments for startup options,
* to start as service or console mode application in windows.
* Invokes appropriate startup functions depending on the
* parameters passed
*************************************************************/
int
__cdecl
_tmain(int argc, TCHAR * argv[])
{
/*
* Define Service Name and Description, which appears in windows SCM
*/
LPCTSTR lpszServiceName = app_name_long; /* Service Registry Name */
LPCTSTR lpszServiceDisplayName = _T("Net-SNMP Agent"); /* Display Name */
LPCTSTR lpszServiceDescription =
#ifdef IFDESCR
_T("SNMPv2c / SNMPv3 command responder from Net-SNMP. Supports MIB objects for IP,ICMP,TCP,UDP, and network interface sub-layers.");
#else
_T("SNMPv2c / SNMPv3 command responder from Net-SNMP");
#endif
InputParams InputOptions;
int nRunType = RUN_AS_CONSOLE;
int quiet = 0;
#if 0
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF /*| _CRTDBG_CHECK_ALWAYS_DF*/);
#endif
nRunType = ParseCmdLineForServiceOption(argc, argv, &quiet);
switch (nRunType) {
case REGISTER_SERVICE:
/*
* Register As service
*/
InputOptions.Argc = argc;
InputOptions.Argv = argv;
return RegisterService(lpszServiceName,
lpszServiceDisplayName,
lpszServiceDescription, &InputOptions, quiet);
case UN_REGISTER_SERVICE:
/*
* Unregister service
*/
return UnregisterService(lpszServiceName, quiet);
case RUN_AS_SERVICE:
/*
* Run as service
*/
/*
* Register Stop Function
*/
RegisterStopFunction(StopSnmpAgent);
return RunAsService(SnmpDaemonMain);
default:
/*
* Run in console mode
*/
return SnmpDaemonMain(argc, argv);
}
}
/************************************************************
* main function for Windows
* Parse command line arguments for startup options,
* to start as service or console mode application in windows.
* Invokes appropriate startup funcitons depending on the
* parameters passesd
*************************************************************/
int
__cdecl
_tmain(int argc, TCHAR * argv[])
{
/*
* Define Service Name and Description, which appears in windows SCM
*/
LPCTSTR lpszServiceName = g_szAppName; /* Service Registry Name */
LPCTSTR lpszServiceDisplayName = _T("Net SNMP Agent Daemon"); /* Display Name */
LPCTSTR lpszServiceDescription =
_T("SNMP agent for windows from Net-SNMP");
InputParams InputOptions;
int nRunType = RUN_AS_CONSOLE;
nRunType = ParseCmdLineForServiceOption(argc, argv);
switch (nRunType) {
case REGISTER_SERVICE:
/*
* Register As service
*/
InputOptions.Argc = argc;
InputOptions.Argv = argv;
RegisterService(lpszServiceName,
lpszServiceDisplayName,
lpszServiceDescription, &InputOptions);
exit(0);
break;
case UN_REGISTER_SERVICE:
/*
* Unregister service
*/
UnregisterService(lpszServiceName);
exit(0);
break;
case RUN_AS_SERVICE:
/*
* Run as service
*/
/*
* Register Stop Function
*/
RegisterStopFunction(StopSnmpAgent);
return RunAsService(SnmpDaemonMain);
break;
default:
/*
* Run Net-Snmpd in console mode
*/
/*
* Invoke SnmpDeamonMain with input arguments
*/
return SnmpDaemonMain(argc, argv);
break;
}
}
/************************************************************
* main function for Windows
* Parse command line arguments for startup options,
* to start as service or console mode application in windows.
* Invokes appropriate startup functions depending on the
* parameters passed
*************************************************************/
int
__cdecl
_tmain(int argc, TCHAR * argv[])
{
/*
* Define Service Name and Description, which appears in windows SCM
*/
LPCTSTR lpszServiceName = app_name_long; /* Service Registry Name */
LPCTSTR lpszServiceDisplayName = _T("Net-SNMP Trap Handler"); /* Display Name */
LPCTSTR lpszServiceDescription =
#ifdef IFDESCR
_T("SNMPv2c / SNMPv3 trap/inform receiver from Net-SNMP. Supports MIB objects for IP,ICMP,TCP,UDP, and network interface sub-layers.");
#else
_T("SNMPv2c / SNMPv3 trap/inform receiver from Net-SNMP");
#endif
InputParams InputOptions;
int nRunType = RUN_AS_CONSOLE;
int quiet = 0;
nRunType = ParseCmdLineForServiceOption(argc, argv, &quiet);
switch (nRunType) {
case REGISTER_SERVICE:
/*
* Register As service
*/
InputOptions.Argc = argc;
InputOptions.Argv = argv;
exit (RegisterService(lpszServiceName,
lpszServiceDisplayName,
lpszServiceDescription, &InputOptions, quiet));
break;
case UN_REGISTER_SERVICE:
/*
* Unregister service
*/
exit (UnregisterService(lpszServiceName, quiet));
exit(0);
break;
case RUN_AS_SERVICE:
/*
* Run as service
*/
/*
* Register Stop Function
*/
RegisterStopFunction(StopSnmpTrapd);
return RunAsService(SnmpTrapdMain);
break;
default:
/*
* Run in console mode
*/
return SnmpTrapdMain(argc, argv);
break;
}
}
AutoDiscoveryServerImpl::AutoDiscoveryServerImpl(const std::string& type, unsigned int port)
{
HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);
std::ostringstream ss;
ss << port;
DNSServiceErrorType err = RegisterService(&client, "", type.c_str(), "", NULL, ss.str().c_str(), this);
if (!client || err != kDNSServiceErr_NoError) {
OSG_WARN << "AutoDiscoveryImpl :: DNSService call failed " << (long int)err << std::endl;
}
}
BOOL CRemotePolicyApp::InitInstance()
{
CWinApp::InitInstance();
::OutputDebugString(_T("RemotePolicy InitInstance\n"));
// 使用Mutex确保程序只有一个实例运行
m_hServerMutex = ::CreateMutex(NULL, FALSE,"RemotePolicy_Mutex");
if(m_hServerMutex==NULL)
{
return FALSE;
}
else
{
if(GetLastError()==ERROR_ALREADY_EXISTS)
{
::OutputDebugString(_T("RemotePolicy is already running!\n"));
return FALSE;
}
}
m_hStop = CreateEvent(0, TRUE, FALSE, 0);
if(m_hStop == NULL) return FALSE;
// Socket 初始化
if(!AfxSocketInit()) return FALSE;
//载入注册表参数
/* if(LoadRegistry())
{
//注册表的接收参数载入成功
if(m_RegParam.bRecvOK)
{
//线程数加1，开始接收客户端请求--CPoolThread
// dwThreads++;
TRACE(_T("Begin Listening Client Thread!\n"));
// m_pPoolThread = (CPoolThread*)AfxBeginThread(RUNTIME_CLASS(CPoolThread));
}
else
{
//参数出错处理
TRACE(_T("One of Receiver param is error,so the NDReceiver exit!\n"));
return FALSE;
}
}
else
{
//载入注册表出错处理
TRACE(_T("Read Registory error!\n"));
return FALSE;
}
*/
// NTSercie 注册服务
RegisterService(__argc, __argv);
return TRUE;
}
mitk::FiberBundleVtkWriter::FiberBundleVtkWriter()
: mitk::AbstractFileWriter(mitk::FiberBundle::GetStaticNameOfClass(), mitk::DiffusionIOMimeTypes::FIBERBUNDLE_VTK_MIMETYPE_NAME(), "VTK Fiber Bundle Writer")
{
Options defaultOptions;
defaultOptions["Save as binary file"] = true;
defaultOptions["Save as xml file (vtp style)"] = false;
defaultOptions["Save color information"] = true;
defaultOptions["Save fiber weights"] = true;
this->SetDefaultOptions(defaultOptions);
RegisterService();
}
nsresult
MulticastDNSDeviceProvider::Init()
{
MOZ_ASSERT(NS_IsMainThread());
if (mInitialized) {
return NS_OK;
}
nsresult rv;
mMulticastDNS = do_GetService(DNSSERVICEDISCOVERY_CONTRACT_ID, &rv);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
mWrappedListener = new DNSServiceWrappedListener();
if (NS_WARN_IF(!mWrappedListener)) {
return NS_ERROR_OUT_OF_MEMORY;
}
if (NS_WARN_IF(NS_FAILED(rv = mWrappedListener->SetListener(this)))) {
return rv;
}
mPresentationServer = do_CreateInstance(TCP_PRESENTATION_SERVER_CONTACT_ID, &rv);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
mDiscoveryTimer = do_CreateInstance(NS_TIMER_CONTRACTID, &rv);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
Preferences::AddStrongObservers(this, kObservedPrefs);
mDiscoveryEnabled = Preferences::GetBool(PREF_PRESENTATION_DISCOVERY);
mDiscveryTimeoutMs = Preferences::GetUint(PREF_PRESENTATION_DISCOVERY_TIMEOUT_MS);
mDiscoverable = Preferences::GetBool(PREF_PRESENTATION_DISCOVERABLE);
mServiceName = Preferences::GetCString(PREF_PRESENTATION_DEVICE_NAME);
if (mDiscoveryEnabled && NS_WARN_IF(NS_FAILED(rv = ForceDiscovery()))) {
return rv;
}
if (mDiscoverable && NS_WARN_IF(NS_FAILED(rv = RegisterService()))) {
return rv;
}
mInitialized = true;
return NS_OK;
}
MythFEXML::MythFEXML( UPnpDevice *pDevice , const QString sSharePath)
: Eventing( "MythFEXML", "MYTHTV_Event", sSharePath)
{
QString sUPnpDescPath = UPnp::GetConfiguration()->GetValue( "UPnP/DescXmlPath", m_sSharePath );
m_sServiceDescFileName = sUPnpDescPath + "MFEXML_scpd.xml";
m_sControlUrl = "/MythFE";
// Add our Service Definition to the device.
RegisterService( pDevice );
}
nsresult
MulticastDNSDeviceProvider::OnDiscoverableChanged(bool aEnabled)
{
LOG_I("Discoverable = %d\n", aEnabled);
MOZ_ASSERT(NS_IsMainThread());
mDiscoverable = aEnabled;
if (mDiscoverable) {
return RegisterService();
}
return UnregisterService(NS_OK);
}
mitk::ContourModelWriter::ContourModelWriter()
: AbstractFileWriter(ContourModel::GetStaticNameOfClass())
, m_IndentDepth(0)
, m_Indent(2)
{
std::string category = "Contour File";
mitk::CustomMimeType customMimeType;
customMimeType.SetCategory(category);
customMimeType.AddExtension("cnt");
this->SetDescription(category);
this->SetMimeType(customMimeType);
RegisterService();
}
int main(int argc, char *argv[])
{
WSADATA wsaData;
/* initialize socket subsystem */
if (WSAStartup(MAKEWORD(2,0), &wsaData))
fatal("Cannot start the network subsystem");
/* service cmdline */
if (argc >= 3) {
if (!strcmp(argv[1], "-service")) {
cf_quiet = 1;
cf_config_file = argv[2];
win32_servicestart();
return 0;
}
if (!strcmp(argv[1], "-regservice")) {
int i;
win32_load_config(argv[2]);
for (i = 3; i < argc; i++) {
if (!strcmp(argv[i], "-U") && i + 1 < argc) {
service_username = argv[++i];
} else if (!strcmp(argv[i], "-P") && i + 1 < argc) {
service_password = argv[++i];
} else {
printf("unknown arg: %s\n", argv[i]);
usage(1, argv[0]);
}
}
RegisterService();
return 0;
}
if (!strcmp(argv[1], "-unregservice")) {
win32_load_config(argv[2]);
UnRegisterService();
return 0;
}
}
return exec_real_main(argc, argv);
}
nsresult
MulticastDNSDeviceProvider::OnServiceNameChanged(const nsACString& aServiceName)
{
LOG_I("serviceName = %s\n", PromiseFlatCString(aServiceName).get());
MOZ_ASSERT(NS_IsMainThread());
mServiceName = aServiceName;
nsresult rv;
if (NS_WARN_IF(NS_FAILED(rv = UnregisterService(NS_OK)))) {
return rv;
}
if (mDiscoverable) {
return RegisterService();
}
return NS_OK;
}
NS_IMETHODIMP
MulticastDNSDeviceProvider::OnRegistrationFailed(nsIDNSServiceInfo* aServiceInfo,
int32_t aErrorCode)
{
LOG_E("OnRegistrationFailed: %d", aErrorCode);
MOZ_ASSERT(NS_IsMainThread());
mRegisterRequest = nullptr;
nsresult rv;
if (aErrorCode == nsIDNSRegistrationListener::ERROR_SERVICE_NOT_RUNNING) {
if (NS_WARN_IF(NS_FAILED(rv = RegisterService()))) {
return rv;
}
}
return NS_OK;
}
// nsITCPPresentationServerListener
NS_IMETHODIMP
MulticastDNSDeviceProvider::OnClose(nsresult aReason)
{
LOG_I("OnClose: %x", aReason);
MOZ_ASSERT(NS_IsMainThread());
UnregisterService(aReason);
nsresult rv;
if (mDiscoveryEnabled && NS_WARN_IF(NS_FAILED(rv = ForceDiscovery()))) {
return rv;
}
if (mDiscoverable && NS_WARN_IF(NS_FAILED(rv = RegisterService()))) {
return rv;
}
return NS_OK;
}
int BthUtils::OpenServerConnection(BYTE *rgbSdpRecord, int cSdpRecord, int iChannelOffset, void (*funcPtr)(WCHAR *))
{
int iNameLen=0;
if(m_socketServer==INVALID_SOCKET)
{
m_socketServer = socket (AF_BT, SOCK_STREAM, BTHPROTO_RFCOMM);
if (m_socketServer == INVALID_SOCKET)
{
return WSAGetLastError ();
}
SOCKADDR_BTH sa;
memset (&sa, 0, sizeof(sa));
sa.addressFamily = AF_BT;
sa.port = 0;
if (bind (m_socketServer, (SOCKADDR *)&sa, sizeof(sa)))
{
return WSAGetLastError ();
}
iNameLen = sizeof(sa);
if (getsockname(m_socketServer, (SOCKADDR *)&sa, &iNameLen))
{
return WSAGetLastError ();
}
if(RegisterService(rgbSdpRecord, cSdpRecord, iChannelOffset, (UCHAR)sa.port)!=0)
return WSAGetLastError();
if (listen (m_socketServer, SOMAXCONN))
{
return WSAGetLastError ();
}
}
pCallBackFunction=funcPtr;
m_hReadThread= CreateThread(NULL, 0, ReadData, (LPVOID)this, 0, NULL);
return 0;
}
UPnpMSRR::UPnpMSRR( UPnpDevice *pDevice,
const QString &sSharePath )
: Eventing( "UPnpMSRR", "MSRR_Event", sSharePath)
{
AddVariable( new StateVariable< unsigned short >( "AuthorizationGrantedUpdateID", true ) );
AddVariable( new StateVariable< unsigned short >( "AuthorizationDeniedUpdateID" , true ) );
AddVariable( new StateVariable< unsigned short >( "ValidationSucceededUpdateID" , true ) );
AddVariable( new StateVariable< unsigned short >( "ValidationRevokedUpdateID" , true ) );
SetValue< unsigned short >( "AuthorizationGrantedUpdateID", 0 );
SetValue< unsigned short >( "AuthorizationDeniedUpdateID" , 0 );
SetValue< unsigned short >( "ValidationSucceededUpdateID" , 0 );
SetValue< unsigned short >( "ValidationRevokedUpdateID" , 0 );
QString sUPnpDescPath =
UPnp::GetConfiguration()->GetValue( "UPnP/DescXmlPath", m_sSharePath );
m_sServiceDescFileName = sUPnpDescPath + "MSRR_scpd.xml";
m_sControlUrl = "/MSRR_Control";
// Add our Service Definition to the device.
RegisterService( pDevice );
}
int _tmain(int argc, LPTSTR* argv)
{
g_errorCode = ERROR_NONE;
switch (ParseCallerParameters(argc, argv))
{
case REQUEST_REGISTER:
g_errorCode = RegisterService(L"FileChecker", L"File Checker");
break;
case REQUEST_UNREGISTER:
g_errorCode = UnregisterService(L"FileChecker");
break;
case REQUEST_RUN:
RunService();
break;
default:
g_errorCode = ERROR_INVALID_REQUEST;
}
return HandleErrorCode(g_errorCode);
}
/*
* User pressed the install button. Make it go.
*/
void CBINDInstallDlg::OnInstall() {
BOOL success = FALSE;
int oldlen;
if (CheckBINDService())
StopBINDService();
InstallTags();
UpdateData();
/*
* Check that the Passwords entered match.
*/
if (m_accountPassword != m_accountPasswordConfirm) {
MsgBox(IDS_ERR_PASSWORD);
return;
}
/*
* Check that there is not leading / trailing whitespace.
* This is for compatability with the standard password dialog.
* Passwords really should be treated as opaque blobs.
*/
oldlen = m_accountPassword.GetLength();
m_accountPassword.TrimLeft();
m_accountPassword.TrimRight();
if (m_accountPassword.GetLength() != oldlen) {
MsgBox(IDS_ERR_WHITESPACE);
return;
}
/*
* Check the entered account name.
*/
if (ValidateServiceAccount() == FALSE)
return;
/*
* For Registration we need to know if account was changed.
*/
if (m_accountName != m_currentAccount)
m_accountUsed = FALSE;
if (m_accountUsed == FALSE && m_serviceExists == FALSE)
{
/*
* Check that the Password is not null.
*/
if (m_accountPassword.GetLength() == 0) {
MsgBox(IDS_ERR_NULLPASSWORD);
return;
}
}
/* Directories */
m_etcDir = m_targetDir + "\\etc";
m_binDir = m_targetDir + "\\bin";
if (m_defaultDir != m_targetDir) {
if (GetFileAttributes(m_targetDir) != 0xFFFFFFFF)
{
int install = MsgBox(IDS_DIREXIST,
MB_YESNO | MB_ICONQUESTION, m_targetDir);
if (install == IDNO)
return;
}
else {
int createDir = MsgBox(IDS_CREATEDIR,
MB_YESNO | MB_ICONQUESTION, m_targetDir);
if (createDir == IDNO)
return;
}
}
if (m_accountExists == FALSE) {
success = CreateServiceAccount(m_accountName.GetBuffer(30),
m_accountPassword.GetBuffer(30));
if (success == FALSE) {
MsgBox(IDS_CREATEACCOUNT_FAILED);
return;
}
m_accountExists = TRUE;
}
ProgramGroup(FALSE);
try {
CreateDirs();
CopyFiles();
RegisterService();
RegisterMessages();
HKEY hKey;
/* Create a new key for named */
SetCurrent(IDS_CREATE_KEY);
if (RegCreateKey(HKEY_LOCAL_MACHINE, BIND_SUBKEY,
&hKey) == ERROR_SUCCESS) {
// Get the install directory
RegSetValueEx(hKey, "InstallDir", 0, REG_SZ,
(LPBYTE)(LPCTSTR)m_targetDir,
m_targetDir.GetLength());
RegCloseKey(hKey);
}
SetCurrent(IDS_ADD_REMOVE);
if (RegCreateKey(HKEY_LOCAL_MACHINE, BIND_UNINSTALL_SUBKEY,
&hKey) == ERROR_SUCCESS) {
CString buf(BIND_DISPLAY_NAME);
RegSetValueEx(hKey, "DisplayName", 0, REG_SZ,
(LPBYTE)(LPCTSTR)buf, buf.GetLength());
buf.Format("%s\\BINDInstall.exe", m_binDir);
RegSetValueEx(hKey, "UninstallString", 0, REG_SZ,
(LPBYTE)(LPCTSTR)buf, buf.GetLength());
RegCloseKey(hKey);
}
ProgramGroup(FALSE);
if (m_startOnInstall)
StartBINDService();
}
catch(Exception e) {
MessageBox(e.resString);
SetCurrent(IDS_CLEANUP);
FailedInstall();
MsgBox(IDS_FAIL);
return;
}
catch(DWORD dw) {
CString msg;
msg.Format("A fatal error occured\n(%s)", GetErrMessage(dw));
MessageBox(msg);
SetCurrent(IDS_CLEANUP);
FailedInstall();
MsgBox(IDS_FAIL);
return;
}
SetCurrent(IDS_INSTALL_DONE);
MsgBox(IDS_SUCCESS);
}
void OpenServer( void ) /*FOLD00*/
{
l.MsgBaseServer = RegisterService( WIDE("Benchmark Service"), functions, NUM_FUNCTIONS );
}
ComponentImpl::ComponentImpl()
{
RegisterService("my_microturbine", new ::my_microturbineWrapper(this));
}
void OpenServer( void )
{
l.MsgBaseServer = RegisterService( WIDE("systray"), functions, NUM_FUNCTIONS );
xlprintf(LOG_ADVISORY)("l.MsgBaseServer is %lu", l.MsgBaseServer );
}
mDNSexport int main(int argc, char **argv)
{
mStatus status;
sigset_t signals;
if (argc < 3) goto usage;
status = mDNS_Init(&mDNSStorage, &PlatformStorage,
mDNS_Init_NoCache, mDNS_Init_ZeroCacheSize,
mDNS_Init_DontAdvertiseLocalAddresses,
mDNS_Init_NoInitCallback, mDNS_Init_NoInitCallbackContext);
if (status) { fprintf(stderr, "Daemon start: mDNS_Init failed %d\n", (int)status); return(status); }
mDNSPosixListenForSignalInEventLoop(SIGINT);
mDNSPosixListenForSignalInEventLoop(SIGTERM);
if (!strcmp(argv[1], "-"))
{
domainname proxyhostname;
AuthRecord proxyrecord;
if (argc < 5) goto usage;
proxyhostname.c[0] = 0;
AppendLiteralLabelString(&proxyhostname, argv[2]);
AppendLiteralLabelString(&proxyhostname, "local");
RegisterNoSuchService(&mDNSStorage, &proxyrecord, &proxyhostname, argv[3], argv[4], "local.");
}
else
{
ProxyHost proxyhost;
ServiceRecordSet proxyservice;
proxyhost.ip.NotAnInteger = inet_addr(argv[1]);
if (proxyhost.ip.NotAnInteger == INADDR_NONE) // INADDR_NONE is 0xFFFFFFFF
{
struct hostent *h = gethostbyname(argv[1]);
if (h) proxyhost.ip.NotAnInteger = *(long*)h->h_addr;
}
if (proxyhost.ip.NotAnInteger == INADDR_NONE) // INADDR_NONE is 0xFFFFFFFF
{
fprintf(stderr, "%s is not valid host address\n", argv[1]);
return(-1);
}
MakeDomainLabelFromLiteralString(&proxyhost.hostlabel, argv[2]);
mDNS_RegisterProxyHost(&mDNSStorage, &proxyhost);
if (argc >=6)
RegisterService(&mDNSStorage, &proxyservice, argv[3], argv[4], "local.",
proxyhost.RR_A.resrec.name, atoi(argv[5]), argc-6, &argv[6]);
}
do
{
struct timeval timeout = { 0x3FFFFFFF, 0 }; // wait until SIGINT or SIGTERM
mDNSBool gotSomething;
mDNSPosixRunEventLoopOnce(&mDNSStorage, &timeout, &signals, &gotSomething);
}
while ( !( sigismember( &signals, SIGINT) || sigismember( &signals, SIGTERM)));
mDNS_Close(&mDNSStorage);
return(0);
usage:
fprintf(stderr, "%s ip hostlabel [srvname srvtype port txt [txt ...]]\n", argv[0]);
fprintf(stderr, "ip Real IP address (or valid host name) of the host where the service actually resides\n");
fprintf(stderr, "hostlabel First label of the dot-local host name to create for this host, e.g. \"foo\" for \"foo.local.\"\n");
fprintf(stderr, "srvname Descriptive name of service, e.g. \"Stuart's Ink Jet Printer\"\n");
fprintf(stderr, "srvtype IANA service type, e.g. \"_ipp._tcp\" or \"_ssh._tcp\", etc.\n");
fprintf(stderr, "port Port number where the service resides (1-65535)\n");
fprintf(stderr, "txt Additional name/value pairs specified in service definition, e.g. \"pdl=application/postscript\"\n");
fprintf(stderr, "e.g. %s 169.254.12.34 thehost (just create a dot-local host name)\n", argv[0]);
fprintf(stderr, "or %s 169.254.12.34 thehost \"My Printer\" _printer._tcp. 515 rp=lpt1 pdl=application/postscript\n", argv[0]);
fprintf(stderr, "or %s - thehost \"My Printer\" _printer._tcp. (assertion of non-existence)\n", argv[0]);
return(-1);
}