1 /* -*- Mode: C; tab-width: 4 -*- 2 * 3 * Copyright (c) 2003-2004 Apple Computer, Inc. All rights reserved. 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 #include <stdio.h> 19 #include <stdlib.h> 20 #include <crtdbg.h> 21 #include <stdarg.h> 22 #include <stddef.h> 23 24 25 #include "CommonServices.h" 26 #include "DebugServices.h" 27 #include "RegNames.h" 28 29 #include "uds_daemon.h" 30 #include "GenLinkedList.h" 31 #include "Service.h" 32 #include "mDNSWindows/SystemService/EventLog.h" 33 34 #include "Resource.h" 35 36 #include "mDNSEmbeddedAPI.h" 37 #include "uDNS.h" 38 #include "mDNSWin32.h" 39 40 #include "Firewall.h" 41 42 #if( !TARGET_OS_WINDOWS_CE ) 43 #include <mswsock.h> 44 #include <process.h> 45 #include <ipExport.h> 46 #include <ws2def.h> 47 #include <ws2ipdef.h> 48 #include <iphlpapi.h> 49 #include <netioapi.h> 50 #include <iptypes.h> 51 #include <powrprof.h> 52 #endif 53 54 #ifndef HeapEnableTerminationOnCorruption 55 # define HeapEnableTerminationOnCorruption (HEAP_INFORMATION_CLASS)1 56 #endif 57 58 #if 0 59 #pragma mark == Constants == 60 #endif 61 62 //=========================================================================================================================== 63 // Constants 64 //=========================================================================================================================== 65 66 #define DEBUG_NAME "[mDNSWin32] " 67 #define kServiceFirewallName L"Bonjour" 68 #define kServiceDependencies TEXT("Tcpip\0\0") 69 #define kDNSServiceCacheEntryCountDefault 512 70 #define kRetryFirewallPeriod 30 * 1000 71 #define kDefValueSize MAX_PATH + 1 72 #define kZeroIndex 0 73 #define kDefaultRouteMetric 399 74 #define kSecondsTo100NSUnits ( 10 * 1000 * 1000 ) 75 #define kSPSMaintenanceWakePeriod -30 76 77 #define RR_CACHE_SIZE 500 78 static CacheEntity gRRCache[RR_CACHE_SIZE]; 79 #if 0 80 #pragma mark == Structures == 81 #endif 82 83 //=========================================================================================================================== 84 // Structures 85 //=========================================================================================================================== 86 87 typedef struct EventSource 88 { 89 HANDLE event; 90 void * context; 91 RegisterWaitableEventHandler handler; 92 struct EventSource * next; 93 } EventSource; 94 95 static BOOL gEventSourceListChanged = FALSE; 96 static EventSource * gEventSourceList = NULL; 97 static EventSource * gCurrentSource = NULL; 98 static int gEventSources = 0; 99 100 #define kWaitListStopEvent ( WAIT_OBJECT_0 + 0 ) 101 #define kWaitListInterfaceListChangedEvent ( WAIT_OBJECT_0 + 1 ) 102 #define kWaitListComputerDescriptionEvent ( WAIT_OBJECT_0 + 2 ) 103 #define kWaitListTCPIPEvent ( WAIT_OBJECT_0 + 3 ) 104 #define kWaitListDynDNSEvent ( WAIT_OBJECT_0 + 4 ) 105 #define kWaitListFileShareEvent ( WAIT_OBJECT_0 + 5 ) 106 #define kWaitListFirewallEvent ( WAIT_OBJECT_0 + 6 ) 107 #define kWaitListAdvertisedServicesEvent ( WAIT_OBJECT_0 + 7 ) 108 #define kWaitListSPSWakeupEvent ( WAIT_OBJECT_0 + 8 ) 109 #define kWaitListSPSSleepEvent ( WAIT_OBJECT_0 + 9 ) 110 #define kWaitListFixedItemCount 10 111 112 113 #if 0 114 #pragma mark == Prototypes == 115 #endif 116 117 //=========================================================================================================================== 118 // Prototypes 119 //=========================================================================================================================== 120 static void Usage( void ); 121 static BOOL WINAPI ConsoleControlHandler( DWORD inControlEvent ); 122 static OSStatus InstallService( LPCTSTR inName, LPCTSTR inDisplayName, LPCTSTR inDescription, LPCTSTR inPath ); 123 static OSStatus RemoveService( LPCTSTR inName ); 124 static OSStatus SetServiceParameters(); 125 static OSStatus GetServiceParameters(); 126 static OSStatus CheckFirewall(); 127 static OSStatus SetServiceInfo( SC_HANDLE inSCM, LPCTSTR inServiceName, LPCTSTR inDescription ); 128 static void ReportStatus( int inType, const char *inFormat, ... ); 129 130 static void WINAPI ServiceMain( DWORD argc, LPTSTR argv[] ); 131 static OSStatus ServiceSetupEventLogging( void ); 132 static DWORD WINAPI ServiceControlHandler( DWORD inControl, DWORD inEventType, LPVOID inEventData, LPVOID inContext ); 133 134 static OSStatus ServiceRun( int argc, LPTSTR argv[] ); 135 static void ServiceStop( void ); 136 137 static OSStatus ServiceSpecificInitialize( int argc, LPTSTR argv[] ); 138 static OSStatus ServiceSpecificRun( int argc, LPTSTR argv[] ); 139 static OSStatus ServiceSpecificStop( void ); 140 static void ServiceSpecificFinalize( int argc, LPTSTR argv[] ); 141 static mStatus SetupNotifications(); 142 static mStatus TearDownNotifications(); 143 static mStatus RegisterWaitableEvent( mDNS * const inMDNS, HANDLE event, void * context, RegisterWaitableEventHandler handler ); 144 static void UnregisterWaitableEvent( mDNS * const inMDNS, HANDLE event ); 145 static mStatus SetupWaitList( mDNS * const inMDNS, HANDLE **outWaitList, int *outWaitListCount ); 146 static void UDSCanAccept( mDNS * const inMDNS, HANDLE event, void * context ); 147 static void UDSCanRead( TCPSocket * sock ); 148 static void HandlePowerSuspend( void * v ); 149 static void HandlePowerResumeSuspend( void * v ); 150 static void CoreCallback(mDNS * const inMDNS, mStatus result); 151 static mDNSu8 SystemWakeForNetworkAccess( LARGE_INTEGER * timeout ); 152 static OSStatus GetRouteDestination(DWORD * ifIndex, DWORD * address); 153 static OSStatus SetLLRoute( mDNS * const inMDNS ); 154 static bool HaveRoute( PMIB_IPFORWARDROW rowExtant, unsigned long addr, unsigned long metric ); 155 static bool IsValidAddress( const char * addr ); 156 static bool IsNortelVPN( IP_ADAPTER_INFO * pAdapter ); 157 static bool IsJuniperVPN( IP_ADAPTER_INFO * pAdapter ); 158 static bool IsCiscoVPN( IP_ADAPTER_INFO * pAdapter ); 159 static const char * strnistr( const char * string, const char * subString, size_t max ); 160 161 #if defined(UNICODE) 162 # define StrLen(X) wcslen(X) 163 # define StrCmp(X,Y) wcscmp(X,Y) 164 #else 165 # define StrLen(X) strlen(X) 166 # define StrCmp(X,Y) strcmp(X,Y) 167 #endif 168 169 170 #define kLLNetworkAddr "169.254.0.0" 171 #define kLLNetworkAddrMask "255.255.0.0" 172 173 174 #include "mDNSEmbeddedAPI.h" 175 176 #if 0 177 #pragma mark == Globals == 178 #endif 179 180 //=========================================================================================================================== 181 // Globals 182 //=========================================================================================================================== 183 #define gMDNSRecord mDNSStorage 184 DEBUG_LOCAL mDNS_PlatformSupport gPlatformStorage; 185 DEBUG_LOCAL BOOL gServiceQuietMode = FALSE; 186 DEBUG_LOCAL SERVICE_TABLE_ENTRY gServiceDispatchTable[] = 187 { 188 { kServiceName, ServiceMain }, 189 { NULL, NULL } 190 }; 191 DEBUG_LOCAL SOCKET gInterfaceListChangedSocket = INVALID_SOCKET; 192 DEBUG_LOCAL HANDLE gInterfaceListChangedEvent = NULL; 193 DEBUG_LOCAL HKEY gDescKey = NULL; 194 DEBUG_LOCAL HANDLE gDescChangedEvent = NULL; // Computer description changed event 195 DEBUG_LOCAL HKEY gTcpipKey = NULL; 196 DEBUG_LOCAL HANDLE gTcpipChangedEvent = NULL; // TCP/IP config changed 197 DEBUG_LOCAL HKEY gDdnsKey = NULL; 198 DEBUG_LOCAL HANDLE gDdnsChangedEvent = NULL; // DynDNS config changed 199 DEBUG_LOCAL HKEY gFileSharingKey = NULL; 200 DEBUG_LOCAL HANDLE gFileSharingChangedEvent = NULL; // File Sharing changed 201 DEBUG_LOCAL HKEY gFirewallKey = NULL; 202 DEBUG_LOCAL HANDLE gFirewallChangedEvent = NULL; // Firewall changed 203 DEBUG_LOCAL HKEY gAdvertisedServicesKey = NULL; 204 DEBUG_LOCAL HANDLE gAdvertisedServicesChangedEvent = NULL; // Advertised services changed 205 DEBUG_LOCAL SERVICE_STATUS gServiceStatus; 206 DEBUG_LOCAL SERVICE_STATUS_HANDLE gServiceStatusHandle = NULL; 207 DEBUG_LOCAL HANDLE gServiceEventSource = NULL; 208 DEBUG_LOCAL bool gServiceAllowRemote = false; 209 DEBUG_LOCAL int gServiceCacheEntryCount = 0; // 0 means to use the DNS-SD default. 210 DEBUG_LOCAL bool gServiceManageLLRouting = true; 211 DEBUG_LOCAL int gWaitCount = 0; 212 DEBUG_LOCAL HANDLE * gWaitList = NULL; 213 DEBUG_LOCAL HANDLE gStopEvent = NULL; 214 DEBUG_LOCAL HANDLE gSPSWakeupEvent = NULL; 215 DEBUG_LOCAL HANDLE gSPSSleepEvent = NULL; 216 DEBUG_LOCAL HANDLE gUDSEvent = NULL; 217 DEBUG_LOCAL SocketRef gUDSSocket = 0; 218 DEBUG_LOCAL udsEventCallback gUDSCallback = NULL; 219 DEBUG_LOCAL BOOL gRetryFirewall = FALSE; 220 DEBUG_LOCAL DWORD gOSMajorVersion; 221 DEBUG_LOCAL DWORD gOSMinorVersion; 222 223 typedef DWORD ( WINAPI * GetIpInterfaceEntryFunctionPtr )( PMIB_IPINTERFACE_ROW ); 224 mDNSlocal HMODULE gIPHelperLibraryInstance = NULL; 225 mDNSlocal GetIpInterfaceEntryFunctionPtr gGetIpInterfaceEntryFunctionPtr = NULL; 226 227 228 #if 0 229 #pragma mark - 230 #endif 231 232 //=========================================================================================================================== 233 // Main 234 //=========================================================================================================================== 235 int Main( int argc, LPTSTR argv[] ) 236 { 237 OSStatus err; 238 BOOL ok; 239 BOOL start; 240 int i; 241 242 HeapSetInformation( NULL, HeapEnableTerminationOnCorruption, NULL, 0 ); 243 244 debug_initialize( kDebugOutputTypeMetaConsole ); 245 debug_set_property( kDebugPropertyTagPrintLevel, kDebugLevelVerbose ); 246 247 // Default to automatically starting the service dispatcher if no extra arguments are specified. 248 249 start = ( argc <= 1 ); 250 251 // Parse arguments. 252 253 for( i = 1; i < argc; ++i ) 254 { 255 if( StrCmp( argv[ i ], TEXT("-install") ) == 0 ) // Install 256 { 257 TCHAR desc[ 256 ]; 258 259 desc[ 0 ] = 0; 260 LoadString( GetModuleHandle( NULL ), IDS_SERVICE_DESCRIPTION, desc, sizeof( desc ) ); 261 err = InstallService( kServiceName, kServiceName, desc, argv[0] ); 262 if( err ) 263 { 264 ReportStatus( EVENTLOG_ERROR_TYPE, "install service failed (%d)\n", err ); 265 goto exit; 266 } 267 } 268 else if( StrCmp( argv[ i ], TEXT("-remove") ) == 0 ) // Remove 269 { 270 err = RemoveService( kServiceName ); 271 if( err ) 272 { 273 ReportStatus( EVENTLOG_ERROR_TYPE, "remove service failed (%d)\n", err ); 274 goto exit; 275 } 276 } 277 else if( StrCmp( argv[ i ], TEXT("-start") ) == 0 ) // Start 278 { 279 start = TRUE; 280 } 281 else if( StrCmp( argv[ i ], TEXT("-server") ) == 0 ) // Server 282 { 283 err = RunDirect( argc, argv ); 284 if( err ) 285 { 286 ReportStatus( EVENTLOG_ERROR_TYPE, "run service directly failed (%d)\n", err ); 287 } 288 goto exit; 289 } 290 else if( StrCmp( argv[ i ], TEXT("-q") ) == 0 ) // Quiet Mode (toggle) 291 { 292 gServiceQuietMode = !gServiceQuietMode; 293 } 294 else if( ( StrCmp( argv[ i ], TEXT("-help") ) == 0 ) || // Help 295 ( StrCmp( argv[ i ], TEXT("-h") ) == 0 ) ) 296 { 297 Usage(); 298 err = 0; 299 break; 300 } 301 else 302 { 303 Usage(); 304 err = kParamErr; 305 break; 306 } 307 } 308 309 // Start the service dispatcher if requested. This does not return until all services have terminated. If any 310 // global initialization is needed, it should be done before starting the service dispatcher, but only if it 311 // will take less than 30 seconds. Otherwise, use a separate thread for it and start the dispatcher immediately. 312 313 if( start ) 314 { 315 ok = StartServiceCtrlDispatcher( gServiceDispatchTable ); 316 err = translate_errno( ok, (OSStatus) GetLastError(), kInUseErr ); 317 if( err != kNoErr ) 318 { 319 ReportStatus( EVENTLOG_ERROR_TYPE, "start service dispatcher failed (%d)\n", err ); 320 goto exit; 321 } 322 } 323 err = 0; 324 325 exit: 326 dlog( kDebugLevelTrace, DEBUG_NAME "exited (%d %m)\n", err, err ); 327 _CrtDumpMemoryLeaks(); 328 return( (int) err ); 329 } 330 331 //=========================================================================================================================== 332 // Usage 333 //=========================================================================================================================== 334 335 static void Usage( void ) 336 { 337 fprintf( stderr, "\n" ); 338 fprintf( stderr, "mDNSResponder 1.0d1\n" ); 339 fprintf( stderr, "\n" ); 340 fprintf( stderr, " <no args> Runs the service normally\n" ); 341 fprintf( stderr, " -install Creates the service and starts it\n" ); 342 fprintf( stderr, " -remove Stops the service and deletes it\n" ); 343 fprintf( stderr, " -start Starts the service dispatcher after processing all other arguments\n" ); 344 fprintf( stderr, " -server Runs the service directly as a server (for debugging)\n" ); 345 fprintf( stderr, " -q Toggles Quiet Mode (no events or output)\n" ); 346 fprintf( stderr, " -remote Allow remote connections\n" ); 347 fprintf( stderr, " -cache n Number of mDNS cache entries (defaults to %d)\n", kDNSServiceCacheEntryCountDefault ); 348 fprintf( stderr, " -h[elp] Display Help/Usage\n" ); 349 fprintf( stderr, "\n" ); 350 } 351 352 //=========================================================================================================================== 353 // ConsoleControlHandler 354 //=========================================================================================================================== 355 356 static BOOL WINAPI ConsoleControlHandler( DWORD inControlEvent ) 357 { 358 BOOL handled; 359 OSStatus err; 360 361 handled = FALSE; 362 switch( inControlEvent ) 363 { 364 case CTRL_C_EVENT: 365 case CTRL_BREAK_EVENT: 366 case CTRL_CLOSE_EVENT: 367 case CTRL_LOGOFF_EVENT: 368 case CTRL_SHUTDOWN_EVENT: 369 err = ServiceSpecificStop(); 370 require_noerr( err, exit ); 371 372 handled = TRUE; 373 break; 374 375 default: 376 break; 377 } 378 379 exit: 380 return( handled ); 381 } 382 383 //=========================================================================================================================== 384 // InstallService 385 //=========================================================================================================================== 386 387 static OSStatus InstallService( LPCTSTR inName, LPCTSTR inDisplayName, LPCTSTR inDescription, LPCTSTR inPath ) 388 { 389 OSStatus err; 390 SC_HANDLE scm; 391 SC_HANDLE service; 392 BOOL ok; 393 TCHAR fullPath[ MAX_PATH ]; 394 TCHAR * namePtr; 395 DWORD size; 396 397 scm = NULL; 398 service = NULL; 399 400 // Get a full path to the executable since a relative path may have been specified. 401 402 size = GetFullPathName( inPath, MAX_PATH, fullPath, &namePtr ); 403 err = translate_errno( size > 0, (OSStatus) GetLastError(), kPathErr ); 404 require_noerr( err, exit ); 405 406 // Create the service and start it. 407 408 scm = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS ); 409 err = translate_errno( scm, (OSStatus) GetLastError(), kOpenErr ); 410 require_noerr( err, exit ); 411 412 service = CreateService( scm, inName, inDisplayName, SERVICE_ALL_ACCESS, SERVICE_WIN32_SHARE_PROCESS, 413 SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, fullPath, NULL, NULL, kServiceDependencies, 414 NULL, NULL ); 415 err = translate_errno( service, (OSStatus) GetLastError(), kDuplicateErr ); 416 require_noerr( err, exit ); 417 418 err = SetServiceParameters(); 419 check_noerr( err ); 420 421 if( inDescription ) 422 { 423 err = SetServiceInfo( scm, inName, inDescription ); 424 check_noerr( err ); 425 } 426 427 ok = StartService( service, 0, NULL ); 428 err = translate_errno( ok, (OSStatus) GetLastError(), kInUseErr ); 429 require_noerr( err, exit ); 430 431 ReportStatus( EVENTLOG_SUCCESS, "installed service\n" ); 432 err = kNoErr; 433 434 exit: 435 if( service ) 436 { 437 CloseServiceHandle( service ); 438 } 439 if( scm ) 440 { 441 CloseServiceHandle( scm ); 442 } 443 return( err ); 444 } 445 446 //=========================================================================================================================== 447 // RemoveService 448 //=========================================================================================================================== 449 450 static OSStatus RemoveService( LPCTSTR inName ) 451 { 452 OSStatus err; 453 SC_HANDLE scm; 454 SC_HANDLE service; 455 BOOL ok; 456 SERVICE_STATUS status; 457 458 scm = NULL; 459 service = NULL; 460 461 // Open a connection to the service. 462 463 scm = OpenSCManager( 0, 0, SC_MANAGER_ALL_ACCESS ); 464 err = translate_errno( scm, (OSStatus) GetLastError(), kOpenErr ); 465 require_noerr( err, exit ); 466 467 service = OpenService( scm, inName, SERVICE_STOP | SERVICE_QUERY_STATUS | DELETE ); 468 err = translate_errno( service, (OSStatus) GetLastError(), kNotFoundErr ); 469 require_noerr( err, exit ); 470 471 // Stop the service, if it is not already stopped, then delete it. 472 473 ok = QueryServiceStatus( service, &status ); 474 err = translate_errno( ok, (OSStatus) GetLastError(), kAuthenticationErr ); 475 require_noerr( err, exit ); 476 477 if( status.dwCurrentState != SERVICE_STOPPED ) 478 { 479 ok = ControlService( service, SERVICE_CONTROL_STOP, &status ); 480 check_translated_errno( ok, (OSStatus) GetLastError(), kAuthenticationErr ); 481 } 482 483 ok = DeleteService( service ); 484 err = translate_errno( ok, (OSStatus) GetLastError(), kDeletedErr ); 485 require_noerr( err, exit ); 486 487 ReportStatus( EVENTLOG_SUCCESS, "Removed service\n" ); 488 err = ERROR_SUCCESS; 489 490 exit: 491 if( service ) 492 { 493 CloseServiceHandle( service ); 494 } 495 if( scm ) 496 { 497 CloseServiceHandle( scm ); 498 } 499 return( err ); 500 } 501 502 503 504 //=========================================================================================================================== 505 // SetServiceParameters 506 //=========================================================================================================================== 507 508 static OSStatus SetServiceParameters() 509 { 510 DWORD value; 511 DWORD valueLen = sizeof(DWORD); 512 DWORD type; 513 OSStatus err; 514 HKEY key; 515 516 key = NULL; 517 518 // 519 // Add/Open Parameters section under service entry in registry 520 // 521 err = RegCreateKey( HKEY_LOCAL_MACHINE, kServiceParametersNode, &key ); 522 require_noerr( err, exit ); 523 524 // 525 // If the value isn't already there, then we create it 526 // 527 err = RegQueryValueEx(key, kServiceManageLLRouting, 0, &type, (LPBYTE) &value, &valueLen); 528 529 if (err != ERROR_SUCCESS) 530 { 531 value = 1; 532 533 err = RegSetValueEx( key, kServiceManageLLRouting, 0, REG_DWORD, (const LPBYTE) &value, sizeof(DWORD) ); 534 require_noerr( err, exit ); 535 } 536 537 exit: 538 539 if ( key ) 540 { 541 RegCloseKey( key ); 542 } 543 544 return( err ); 545 } 546 547 548 549 //=========================================================================================================================== 550 // GetServiceParameters 551 //=========================================================================================================================== 552 553 static OSStatus GetServiceParameters() 554 { 555 DWORD value; 556 DWORD valueLen; 557 DWORD type; 558 OSStatus err; 559 HKEY key; 560 561 key = NULL; 562 563 // 564 // Add/Open Parameters section under service entry in registry 565 // 566 err = RegCreateKey( HKEY_LOCAL_MACHINE, kServiceParametersNode, &key ); 567 require_noerr( err, exit ); 568 569 valueLen = sizeof(DWORD); 570 err = RegQueryValueEx(key, kServiceManageLLRouting, 0, &type, (LPBYTE) &value, &valueLen); 571 if (err == ERROR_SUCCESS) 572 { 573 gServiceManageLLRouting = (value) ? true : false; 574 } 575 576 valueLen = sizeof(DWORD); 577 err = RegQueryValueEx(key, kServiceCacheEntryCount, 0, &type, (LPBYTE) &value, &valueLen); 578 if (err == ERROR_SUCCESS) 579 { 580 gServiceCacheEntryCount = value; 581 } 582 583 exit: 584 585 if ( key ) 586 { 587 RegCloseKey( key ); 588 } 589 590 return( err ); 591 } 592 593 594 //=========================================================================================================================== 595 // CheckFirewall 596 //=========================================================================================================================== 597 598 static OSStatus CheckFirewall() 599 { 600 DWORD value; 601 DWORD valueLen; 602 DWORD type; 603 ENUM_SERVICE_STATUS * lpService = NULL; 604 SC_HANDLE sc = NULL; 605 HKEY key = NULL; 606 BOOL ok; 607 DWORD bytesNeeded = 0; 608 DWORD srvCount; 609 DWORD resumeHandle = 0; 610 DWORD srvType; 611 DWORD srvState; 612 DWORD dwBytes = 0; 613 DWORD i; 614 BOOL isRunning = FALSE; 615 OSStatus err = kUnknownErr; 616 617 // Check to see if the firewall service is running. If it isn't, then 618 // we want to return immediately 619 620 sc = OpenSCManager( NULL, NULL, SC_MANAGER_ENUMERATE_SERVICE ); 621 err = translate_errno( sc, GetLastError(), kUnknownErr ); 622 require_noerr( err, exit ); 623 624 srvType = SERVICE_WIN32; 625 srvState = SERVICE_STATE_ALL; 626 627 for ( ;; ) 628 { 629 // Call EnumServicesStatus using the handle returned by OpenSCManager 630 631 ok = EnumServicesStatus ( sc, srvType, srvState, lpService, dwBytes, &bytesNeeded, &srvCount, &resumeHandle ); 632 633 if ( ok || ( GetLastError() != ERROR_MORE_DATA ) ) 634 { 635 break; 636 } 637 638 if ( lpService ) 639 { 640 free( lpService ); 641 } 642 643 dwBytes = bytesNeeded; 644 645 lpService = ( ENUM_SERVICE_STATUS* ) malloc( dwBytes ); 646 require_action( lpService, exit, err = mStatus_NoMemoryErr ); 647 } 648 649 err = translate_errno( ok, GetLastError(), kUnknownErr ); 650 require_noerr( err, exit ); 651 652 for ( i = 0; i < srvCount; i++ ) 653 { 654 if ( wcscmp( lpService[i].lpServiceName, L"SharedAccess" ) == 0 ) 655 { 656 if ( lpService[i].ServiceStatus.dwCurrentState == SERVICE_RUNNING ) 657 { 658 isRunning = TRUE; 659 } 660 661 break; 662 } 663 } 664 665 require_action( isRunning, exit, err = kUnknownErr ); 666 667 // Check to see if we've managed the firewall. 668 // This package might have been installed, then 669 // the OS was upgraded to SP2 or above. If that's 670 // the case, then we need to manipulate the firewall 671 // so networking works correctly. 672 673 err = RegCreateKey( HKEY_LOCAL_MACHINE, kServiceParametersNode, &key ); 674 require_noerr( err, exit ); 675 676 valueLen = sizeof(DWORD); 677 err = RegQueryValueEx(key, kServiceManageFirewall, 0, &type, (LPBYTE) &value, &valueLen); 678 679 if ((err != ERROR_SUCCESS) || (value == 0)) 680 { 681 wchar_t fullPath[ MAX_PATH ]; 682 DWORD size; 683 684 // Get a full path to the executable 685 686 size = GetModuleFileNameW( NULL, fullPath, MAX_PATH ); 687 err = translate_errno( size > 0, (OSStatus) GetLastError(), kPathErr ); 688 require_noerr( err, exit ); 689 690 err = mDNSAddToFirewall(fullPath, kServiceFirewallName); 691 require_noerr( err, exit ); 692 693 value = 1; 694 err = RegSetValueEx( key, kServiceManageFirewall, 0, REG_DWORD, (const LPBYTE) &value, sizeof( DWORD ) ); 695 require_noerr( err, exit ); 696 } 697 698 exit: 699 700 if ( key ) 701 { 702 RegCloseKey( key ); 703 } 704 705 if ( lpService ) 706 { 707 free( lpService ); 708 } 709 710 if ( sc ) 711 { 712 CloseServiceHandle ( sc ); 713 } 714 715 return( err ); 716 } 717 718 719 720 //=========================================================================================================================== 721 // SetServiceInfo 722 //=========================================================================================================================== 723 724 static OSStatus SetServiceInfo( SC_HANDLE inSCM, LPCTSTR inServiceName, LPCTSTR inDescription ) 725 { 726 OSStatus err; 727 SC_LOCK lock; 728 SC_HANDLE service; 729 SERVICE_DESCRIPTION description; 730 SERVICE_FAILURE_ACTIONS actions; 731 SC_ACTION action; 732 BOOL ok; 733 734 check( inServiceName ); 735 check( inDescription ); 736 737 lock = NULL; 738 service = NULL; 739 740 // Open the database (if not provided) and lock it to prevent other access while re-configuring. 741 742 if( !inSCM ) 743 { 744 inSCM = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS ); 745 err = translate_errno( inSCM, (OSStatus) GetLastError(), kOpenErr ); 746 require_noerr( err, exit ); 747 } 748 749 lock = LockServiceDatabase( inSCM ); 750 err = translate_errno( lock, (OSStatus) GetLastError(), kInUseErr ); 751 require_noerr( err, exit ); 752 753 // Open a handle to the service. 754 755 service = OpenService( inSCM, inServiceName, SERVICE_CHANGE_CONFIG|SERVICE_START ); 756 err = translate_errno( service, (OSStatus) GetLastError(), kNotFoundErr ); 757 require_noerr( err, exit ); 758 759 // Change the description. 760 761 description.lpDescription = (LPTSTR) inDescription; 762 ok = ChangeServiceConfig2( service, SERVICE_CONFIG_DESCRIPTION, &description ); 763 err = translate_errno( ok, (OSStatus) GetLastError(), kParamErr ); 764 require_noerr( err, exit ); 765 766 actions.dwResetPeriod = INFINITE; 767 actions.lpRebootMsg = NULL; 768 actions.lpCommand = NULL; 769 actions.cActions = 1; 770 actions.lpsaActions = &action; 771 action.Delay = 500; 772 action.Type = SC_ACTION_RESTART; 773 774 ok = ChangeServiceConfig2( service, SERVICE_CONFIG_FAILURE_ACTIONS, &actions ); 775 err = translate_errno( ok, (OSStatus) GetLastError(), kParamErr ); 776 require_noerr( err, exit ); 777 778 err = ERROR_SUCCESS; 779 780 exit: 781 // Close the service and release the lock. 782 783 if( service ) 784 { 785 CloseServiceHandle( service ); 786 } 787 if( lock ) 788 { 789 UnlockServiceDatabase( lock ); 790 } 791 return( err ); 792 } 793 794 //=========================================================================================================================== 795 // ReportStatus 796 //=========================================================================================================================== 797 798 static void ReportStatus( int inType, const char *inFormat, ... ) 799 { 800 if( !gServiceQuietMode ) 801 { 802 va_list args; 803 804 va_start( args, inFormat ); 805 if( gServiceEventSource ) 806 { 807 char s[ 1024 ]; 808 BOOL ok; 809 const char * array[ 1 ]; 810 811 vsprintf( s, inFormat, args ); 812 array[ 0 ] = s; 813 ok = ReportEventA( gServiceEventSource, (WORD) inType, 0, MDNSRESPONDER_LOG, NULL, 1, 0, array, NULL ); 814 check_translated_errno( ok, GetLastError(), kUnknownErr ); 815 } 816 else 817 { 818 int n; 819 820 n = vfprintf( stderr, inFormat, args ); 821 check( n >= 0 ); 822 } 823 va_end( args ); 824 } 825 } 826 827 //=========================================================================================================================== 828 // RunDirect 829 //=========================================================================================================================== 830 831 int RunDirect( int argc, LPTSTR argv[] ) 832 { 833 OSStatus err; 834 BOOL initialized; 835 BOOL ok; 836 837 initialized = FALSE; 838 839 // Install a Console Control Handler to handle things like control-c signals. 840 841 ok = SetConsoleCtrlHandler( ConsoleControlHandler, TRUE ); 842 err = translate_errno( ok, (OSStatus) GetLastError(), kUnknownErr ); 843 require_noerr( err, exit ); 844 845 err = ServiceSpecificInitialize( argc, argv ); 846 require_noerr( err, exit ); 847 initialized = TRUE; 848 849 // Run the service. This does not return until the service quits or is stopped. 850 851 ReportStatus( EVENTLOG_INFORMATION_TYPE, "Running service directly\n" ); 852 853 err = ServiceSpecificRun( argc, argv ); 854 require_noerr( err, exit ); 855 856 // Clean up. 857 858 exit: 859 if( initialized ) 860 { 861 ServiceSpecificFinalize( argc, argv ); 862 } 863 return( err ); 864 } 865 866 #if 0 867 #pragma mark - 868 #endif 869 870 //=========================================================================================================================== 871 // ServiceMain 872 //=========================================================================================================================== 873 874 static void WINAPI ServiceMain( DWORD argc, LPTSTR argv[] ) 875 { 876 OSStatus err; 877 BOOL ok; 878 879 err = ServiceSetupEventLogging(); 880 check_noerr( err ); 881 882 err = GetServiceParameters(); 883 check_noerr( err ); 884 885 // Initialize the service status and register the service control handler with the name of the service. 886 887 gServiceStatus.dwServiceType = SERVICE_WIN32_SHARE_PROCESS; 888 gServiceStatus.dwCurrentState = 0; 889 gServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP|SERVICE_ACCEPT_SHUTDOWN|SERVICE_ACCEPT_POWEREVENT; 890 gServiceStatus.dwWin32ExitCode = NO_ERROR; 891 gServiceStatus.dwServiceSpecificExitCode = NO_ERROR; 892 gServiceStatus.dwCheckPoint = 0; 893 gServiceStatus.dwWaitHint = 0; 894 895 gServiceStatusHandle = RegisterServiceCtrlHandlerEx( argv[ 0 ], ServiceControlHandler, NULL ); 896 err = translate_errno( gServiceStatusHandle, (OSStatus) GetLastError(), kInUseErr ); 897 require_noerr( err, exit ); 898 899 // Mark the service as starting. 900 901 gServiceStatus.dwCurrentState = SERVICE_START_PENDING; 902 gServiceStatus.dwCheckPoint = 0; 903 gServiceStatus.dwWaitHint = 5000; // 5 seconds 904 ok = SetServiceStatus( gServiceStatusHandle, &gServiceStatus ); 905 check_translated_errno( ok, GetLastError(), kParamErr ); 906 907 // Run the service. This does not return until the service quits or is stopped. 908 909 err = ServiceRun( (int) argc, argv ); 910 if( err != kNoErr ) 911 { 912 gServiceStatus.dwWin32ExitCode = ERROR_SERVICE_SPECIFIC_ERROR; 913 gServiceStatus.dwServiceSpecificExitCode = (DWORD) err; 914 } 915 916 // Service-specific work is done so mark the service as stopped. 917 918 gServiceStatus.dwCurrentState = SERVICE_STOPPED; 919 ok = SetServiceStatus( gServiceStatusHandle, &gServiceStatus ); 920 check_translated_errno( ok, GetLastError(), kParamErr ); 921 922 // Note: The service status handle should not be closed according to Microsoft documentation. 923 924 exit: 925 if( gServiceEventSource ) 926 { 927 ok = DeregisterEventSource( gServiceEventSource ); 928 check_translated_errno( ok, GetLastError(), kUnknownErr ); 929 gServiceEventSource = NULL; 930 } 931 } 932 933 //=========================================================================================================================== 934 // ServiceSetupEventLogging 935 //=========================================================================================================================== 936 937 static OSStatus ServiceSetupEventLogging( void ) 938 { 939 OSStatus err; 940 HKEY key; 941 LPCTSTR s; 942 DWORD typesSupported; 943 TCHAR path[ MAX_PATH ]; 944 DWORD n; 945 946 key = NULL; 947 948 // Add/Open source name as a sub-key under the Application key in the EventLog registry key. 949 950 s = TEXT("SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\") kServiceName; 951 err = RegCreateKey( HKEY_LOCAL_MACHINE, s, &key ); 952 require_noerr( err, exit ); 953 954 // Add the name to the EventMessageFile subkey. 955 956 path[ 0 ] = '\0'; 957 GetModuleFileName( NULL, path, MAX_PATH ); 958 n = (DWORD) ( ( StrLen( path ) + 1 ) * sizeof( TCHAR ) ); 959 err = RegSetValueEx( key, TEXT("EventMessageFile"), 0, REG_EXPAND_SZ, (const LPBYTE) path, n ); 960 require_noerr( err, exit ); 961 962 // Set the supported event types in the TypesSupported subkey. 963 964 typesSupported = 0 965 | EVENTLOG_SUCCESS 966 | EVENTLOG_ERROR_TYPE 967 | EVENTLOG_WARNING_TYPE 968 | EVENTLOG_INFORMATION_TYPE 969 | EVENTLOG_AUDIT_SUCCESS 970 | EVENTLOG_AUDIT_FAILURE; 971 err = RegSetValueEx( key, TEXT("TypesSupported"), 0, REG_DWORD, (const LPBYTE) &typesSupported, sizeof( DWORD ) ); 972 require_noerr( err, exit ); 973 974 // Set up the event source. 975 976 gServiceEventSource = RegisterEventSource( NULL, kServiceName ); 977 err = translate_errno( gServiceEventSource, (OSStatus) GetLastError(), kParamErr ); 978 require_noerr( err, exit ); 979 980 exit: 981 if( key ) 982 { 983 RegCloseKey( key ); 984 } 985 return( err ); 986 } 987 988 //=========================================================================================================================== 989 // HandlePowerSuspend 990 //=========================================================================================================================== 991 992 static void HandlePowerSuspend( void * v ) 993 { 994 LARGE_INTEGER timeout; 995 BOOL ok; 996 997 ( void ) v; 998 999 dlog( kDebugLevelInfo, DEBUG_NAME "HandlePowerSuspend\n" ); 1000 1001 gMDNSRecord.SystemWakeOnLANEnabled = SystemWakeForNetworkAccess( &timeout ); 1002 1003 if ( gMDNSRecord.SystemWakeOnLANEnabled ) 1004 { 1005 ok = SetWaitableTimer( gSPSWakeupEvent, &timeout, 0, NULL, NULL, TRUE ); 1006 check( ok ); 1007 } 1008 1009 mDNSCoreMachineSleep(&gMDNSRecord, TRUE); 1010 } 1011 1012 1013 //=========================================================================================================================== 1014 // HandlePowerResumeSuspend 1015 //=========================================================================================================================== 1016 1017 static void HandlePowerResumeSuspend( void * v ) 1018 { 1019 ( void ) v; 1020 1021 dlog( kDebugLevelInfo, DEBUG_NAME "HandlePowerResumeSuspend\n" ); 1022 1023 if ( gSPSWakeupEvent ) 1024 { 1025 CancelWaitableTimer( gSPSWakeupEvent ); 1026 } 1027 1028 if ( gSPSSleepEvent ) 1029 { 1030 CancelWaitableTimer( gSPSSleepEvent ); 1031 } 1032 1033 mDNSCoreMachineSleep(&gMDNSRecord, FALSE); 1034 } 1035 1036 1037 //=========================================================================================================================== 1038 // ServiceControlHandler 1039 //=========================================================================================================================== 1040 1041 static DWORD WINAPI ServiceControlHandler( DWORD inControl, DWORD inEventType, LPVOID inEventData, LPVOID inContext ) 1042 { 1043 BOOL setStatus; 1044 BOOL ok; 1045 1046 DEBUG_UNUSED( inEventData ); 1047 DEBUG_UNUSED( inContext ); 1048 1049 setStatus = TRUE; 1050 switch( inControl ) 1051 { 1052 case SERVICE_CONTROL_STOP: 1053 case SERVICE_CONTROL_SHUTDOWN: 1054 dlog( kDebugLevelInfo, DEBUG_NAME "ServiceControlHandler: SERVICE_CONTROL_STOP|SERVICE_CONTROL_SHUTDOWN\n" ); 1055 1056 ServiceStop(); 1057 setStatus = FALSE; 1058 break; 1059 1060 case SERVICE_CONTROL_POWEREVENT: 1061 1062 if (inEventType == PBT_APMSUSPEND) 1063 { 1064 dlog( kDebugLevelInfo, DEBUG_NAME "ServiceControlHandler: PBT_APMSUSPEND\n" ); 1065 1066 QueueUserAPC( ( PAPCFUNC ) HandlePowerSuspend, gMDNSRecord.p->mainThread, ( ULONG_PTR ) NULL ); 1067 } 1068 else if (inEventType == PBT_APMRESUMESUSPEND) 1069 { 1070 dlog( kDebugLevelInfo, DEBUG_NAME "ServiceControlHandler: PBT_APMRESUMESUSPEND\n" ); 1071 1072 QueueUserAPC( ( PAPCFUNC ) HandlePowerResumeSuspend, gMDNSRecord.p->mainThread, ( ULONG_PTR ) NULL ); 1073 } 1074 1075 break; 1076 1077 default: 1078 dlog( kDebugLevelNotice, DEBUG_NAME "ServiceControlHandler: event (0x%08X)\n", inControl ); 1079 break; 1080 } 1081 1082 if( setStatus && gServiceStatusHandle ) 1083 { 1084 ok = SetServiceStatus( gServiceStatusHandle, &gServiceStatus ); 1085 check_translated_errno( ok, GetLastError(), kUnknownErr ); 1086 } 1087 1088 return NO_ERROR; 1089 } 1090 1091 //=========================================================================================================================== 1092 // ServiceRun 1093 //=========================================================================================================================== 1094 1095 static OSStatus ServiceRun( int argc, LPTSTR argv[] ) 1096 { 1097 OSStatus err; 1098 BOOL initialized; 1099 BOOL ok; 1100 1101 DEBUG_UNUSED( argc ); 1102 DEBUG_UNUSED( argv ); 1103 1104 initialized = FALSE; 1105 1106 // <rdar://problem/5727548> Make the service as running before we call ServiceSpecificInitialize. We've 1107 // had reports that some machines with McAfee firewall installed cause a problem with iTunes installation. 1108 // We think that the firewall product is interferring with code in ServiceSpecificInitialize. So as a 1109 // simple workaround, we'll mark us as running *before* we call ServiceSpecificInitialize. This will unblock 1110 // any installers that are waiting for our state to change. 1111 1112 gServiceStatus.dwCurrentState = SERVICE_RUNNING; 1113 ok = SetServiceStatus( gServiceStatusHandle, &gServiceStatus ); 1114 check_translated_errno( ok, GetLastError(), kParamErr ); 1115 1116 // Initialize the service-specific stuff 1117 1118 err = ServiceSpecificInitialize( argc, argv ); 1119 require_noerr( err, exit ); 1120 initialized = TRUE; 1121 1122 err = CheckFirewall(); 1123 check_noerr( err ); 1124 1125 if ( err ) 1126 { 1127 gRetryFirewall = TRUE; 1128 } 1129 1130 // Run the service-specific stuff. This does not return until the service quits or is stopped. 1131 1132 ReportStatus( EVENTLOG_INFORMATION_TYPE, "Service started\n" ); 1133 err = ServiceSpecificRun( argc, argv ); 1134 ReportStatus( EVENTLOG_INFORMATION_TYPE, "Service stopped (%d)\n", err ); 1135 require_noerr( err, exit ); 1136 1137 // Service stopped. Clean up and we're done. 1138 1139 exit: 1140 if( initialized ) 1141 { 1142 ServiceSpecificFinalize( argc, argv ); 1143 } 1144 return( err ); 1145 } 1146 1147 //=========================================================================================================================== 1148 // ServiceStop 1149 //=========================================================================================================================== 1150 1151 static void ServiceStop( void ) 1152 { 1153 BOOL ok; 1154 OSStatus err; 1155 1156 // Signal the event to cause the service to exit. 1157 1158 if( gServiceStatusHandle ) 1159 { 1160 gServiceStatus.dwCurrentState = SERVICE_STOP_PENDING; 1161 ok = SetServiceStatus( gServiceStatusHandle, &gServiceStatus ); 1162 check_translated_errno( ok, GetLastError(), kParamErr ); 1163 } 1164 1165 err = ServiceSpecificStop(); 1166 check_noerr( err ); 1167 } 1168 1169 #if 0 1170 #pragma mark - 1171 #pragma mark == Service Specific == 1172 #endif 1173 1174 //=========================================================================================================================== 1175 // ServiceSpecificInitialize 1176 //=========================================================================================================================== 1177 1178 static OSStatus ServiceSpecificInitialize( int argc, LPTSTR argv[] ) 1179 { 1180 OSVERSIONINFO osInfo; 1181 OSStatus err; 1182 BOOL ok; 1183 1184 DEBUG_UNUSED( argc ); 1185 DEBUG_UNUSED( argv ); 1186 1187 mDNSPlatformMemZero( &gMDNSRecord, sizeof gMDNSRecord); 1188 mDNSPlatformMemZero( &gPlatformStorage, sizeof gPlatformStorage); 1189 1190 gPlatformStorage.registerWaitableEventFunc = RegisterWaitableEvent; 1191 gPlatformStorage.unregisterWaitableEventFunc = UnregisterWaitableEvent; 1192 gPlatformStorage.reportStatusFunc = ReportStatus; 1193 1194 err = mDNS_Init( &gMDNSRecord, &gPlatformStorage, gRRCache, RR_CACHE_SIZE, mDNS_Init_AdvertiseLocalAddresses, CoreCallback, mDNS_Init_NoInitCallbackContext); 1195 require_noerr( err, exit); 1196 1197 err = SetupNotifications(); 1198 check_noerr( err ); 1199 1200 err = udsserver_init(mDNSNULL, 0); 1201 require_noerr( err, exit); 1202 1203 // 1204 // Get the version of Windows that we're running on 1205 // 1206 osInfo.dwOSVersionInfoSize = sizeof( OSVERSIONINFO ); 1207 ok = GetVersionEx( &osInfo ); 1208 err = translate_errno( ok, (OSStatus) GetLastError(), kUnknownErr ); 1209 require_noerr( err, exit ); 1210 gOSMajorVersion = osInfo.dwMajorVersion; 1211 gOSMinorVersion = osInfo.dwMinorVersion; 1212 1213 SetLLRoute( &gMDNSRecord ); 1214 1215 exit: 1216 if( err != kNoErr ) 1217 { 1218 ServiceSpecificFinalize( argc, argv ); 1219 } 1220 return( err ); 1221 } 1222 1223 //=========================================================================================================================== 1224 // ServiceSpecificRun 1225 //=========================================================================================================================== 1226 1227 static OSStatus ServiceSpecificRun( int argc, LPTSTR argv[] ) 1228 { 1229 HANDLE * waitList; 1230 int waitListCount; 1231 DWORD timeout; 1232 DWORD result; 1233 BOOL done; 1234 mStatus err; 1235 1236 DEBUG_UNUSED( argc ); 1237 DEBUG_UNUSED( argv ); 1238 1239 timeout = ( gRetryFirewall ) ? kRetryFirewallPeriod : INFINITE; 1240 1241 err = SetupInterfaceList( &gMDNSRecord ); 1242 check( !err ); 1243 1244 err = uDNS_SetupDNSConfig( &gMDNSRecord ); 1245 check( !err ); 1246 1247 done = FALSE; 1248 1249 // Main event loop. 1250 1251 while( !done ) 1252 { 1253 waitList = NULL; 1254 waitListCount = 0; 1255 1256 err = SetupWaitList( &gMDNSRecord, &waitList, &waitListCount ); 1257 require_noerr( err, exit ); 1258 1259 gEventSourceListChanged = FALSE; 1260 1261 while ( !gEventSourceListChanged ) 1262 { 1263 static mDNSs32 RepeatedBusy = 0; 1264 mDNSs32 nextTimerEvent; 1265 1266 // Give the mDNS core a chance to do its work and determine next event time. 1267 1268 nextTimerEvent = udsserver_idle( mDNS_Execute( &gMDNSRecord ) - mDNS_TimeNow( &gMDNSRecord ) ); 1269 1270 if ( nextTimerEvent < 0) nextTimerEvent = 0; 1271 else if ( nextTimerEvent > (0x7FFFFFFF / 1000)) nextTimerEvent = 0x7FFFFFFF / mDNSPlatformOneSecond; 1272 else nextTimerEvent = ( nextTimerEvent * 1000) / mDNSPlatformOneSecond; 1273 1274 // Debugging sanity check, to guard against CPU spins 1275 1276 if ( nextTimerEvent > 0 ) 1277 { 1278 RepeatedBusy = 0; 1279 } 1280 else 1281 { 1282 nextTimerEvent = 1; 1283 1284 if ( ++RepeatedBusy >= mDNSPlatformOneSecond ) 1285 { 1286 ShowTaskSchedulingError( &gMDNSRecord ); 1287 RepeatedBusy = 0; 1288 } 1289 } 1290 1291 if ( gMDNSRecord.ShutdownTime ) 1292 { 1293 mDNSs32 now = mDNS_TimeNow( &gMDNSRecord ); 1294 1295 if ( mDNS_ExitNow( &gMDNSRecord, now ) ) 1296 { 1297 mDNS_FinalExit( &gMDNSRecord ); 1298 done = TRUE; 1299 break; 1300 } 1301 1302 if ( nextTimerEvent - gMDNSRecord.ShutdownTime >= 0 ) 1303 { 1304 nextTimerEvent = gMDNSRecord.ShutdownTime; 1305 } 1306 } 1307 1308 // Wait until something occurs (e.g. cancel, incoming packet, or timeout). 1309 // 1310 // Note: There seems to be a bug in WinSock with respect to Alertable I/O. According 1311 // to MSDN <http://msdn.microsoft.com/en-us/library/aa363772(VS.85).aspx>, Alertable I/O 1312 // callbacks will only be invoked during the following calls (when the caller sets 1313 // the appropriate flag): 1314 // 1315 // - SleepEx 1316 // - WaitForSingleObjectEx 1317 // - WaitForMultipleObjectsEx 1318 // - SignalObjectAndWait 1319 // - MsgWaitForMultipleObjectsEx 1320 // 1321 // However, we have seen callbacks be invoked during calls to bind() (and maybe others). If there 1322 // weren't a bug, then socket events would only be queued during the call to WaitForMultipleObjects() and 1323 // we'd only have to check them once afterwards. However since that doesn't seem to be the case, we'll 1324 // check the queue both before we call WaitForMultipleObjects() and after. 1325 1326 DispatchSocketEvents( &gMDNSRecord ); 1327 result = WaitForMultipleObjectsEx( ( DWORD ) waitListCount, waitList, FALSE, (DWORD) nextTimerEvent, TRUE ); 1328 check( result != WAIT_FAILED ); 1329 DispatchSocketEvents( &gMDNSRecord ); 1330 1331 if ( result != WAIT_FAILED ) 1332 { 1333 if ( result == WAIT_TIMEOUT ) 1334 { 1335 // Next task timeout occurred. Loop back up to give mDNS core a chance to work. 1336 1337 dlog( kDebugLevelChatty - 1, DEBUG_NAME "timeout\n" ); 1338 continue; 1339 } 1340 else if ( result == WAIT_IO_COMPLETION ) 1341 { 1342 dlog( kDebugLevelChatty - 1, DEBUG_NAME "i/o completion\n" ); 1343 continue; 1344 } 1345 else if ( result == kWaitListStopEvent ) 1346 { 1347 // Stop event. Set the done flag and break to exit. 1348 1349 dlog( kDebugLevelVerbose, DEBUG_NAME "stopping...\n" ); 1350 udsserver_exit(); 1351 mDNS_StartExit( &gMDNSRecord ); 1352 break; 1353 } 1354 else if( result == kWaitListInterfaceListChangedEvent ) 1355 { 1356 int inBuffer; 1357 int outBuffer; 1358 DWORD outSize; 1359 1360 // It would be nice to come up with a more elegant solution to this, but it seems that 1361 // GetAdaptersAddresses doesn't always stay in sync after network changed events. So as 1362 // as a simple workaround, we'll pause for a couple of seconds before processing the change. 1363 1364 // We arrived at 2 secs by trial and error. We could reproduce the problem after sleeping 1365 // for 500 msec and 750 msec, but couldn't after sleeping for 1 sec. We added another 1366 // second on top of that to account for machine load or some other exigency. 1367 1368 Sleep( 2000 ); 1369 1370 // Interface list changed event. Break out of the inner loop to re-setup the wait list. 1371 1372 InterfaceListDidChange( &gMDNSRecord ); 1373 1374 // reset the event handler 1375 inBuffer = 0; 1376 outBuffer = 0; 1377 err = WSAIoctl( gInterfaceListChangedSocket, SIO_ADDRESS_LIST_CHANGE, &inBuffer, 0, &outBuffer, 0, &outSize, NULL, NULL ); 1378 if( err < 0 ) 1379 { 1380 check( errno_compat() == WSAEWOULDBLOCK ); 1381 } 1382 } 1383 else if ( result == kWaitListComputerDescriptionEvent ) 1384 { 1385 // The computer description might have changed 1386 1387 ComputerDescriptionDidChange( &gMDNSRecord ); 1388 udsserver_handle_configchange( &gMDNSRecord ); 1389 1390 // and reset the event handler 1391 if ( ( gDescKey != NULL ) && ( gDescChangedEvent != NULL ) ) 1392 { 1393 err = RegNotifyChangeKeyValue( gDescKey, TRUE, REG_NOTIFY_CHANGE_LAST_SET, gDescChangedEvent, TRUE); 1394 check_noerr( err ); 1395 } 1396 } 1397 else if ( result == kWaitListTCPIPEvent ) 1398 { 1399 // The TCP/IP might have changed 1400 1401 TCPIPConfigDidChange( &gMDNSRecord ); 1402 udsserver_handle_configchange( &gMDNSRecord ); 1403 1404 // and reset the event handler 1405 1406 if ( ( gTcpipKey != NULL ) && ( gTcpipChangedEvent ) ) 1407 { 1408 err = RegNotifyChangeKeyValue( gTcpipKey, TRUE, REG_NOTIFY_CHANGE_NAME|REG_NOTIFY_CHANGE_LAST_SET, gTcpipChangedEvent, TRUE ); 1409 check_noerr( err ); 1410 } 1411 } 1412 else if ( result == kWaitListDynDNSEvent ) 1413 { 1414 // The DynDNS config might have changed 1415 1416 DynDNSConfigDidChange( &gMDNSRecord ); 1417 udsserver_handle_configchange( &gMDNSRecord ); 1418 1419 // and reset the event handler 1420 1421 if ((gDdnsKey != NULL) && (gDdnsChangedEvent)) 1422 { 1423 err = RegNotifyChangeKeyValue(gDdnsKey, TRUE, REG_NOTIFY_CHANGE_NAME|REG_NOTIFY_CHANGE_LAST_SET, gDdnsChangedEvent, TRUE); 1424 check_noerr( err ); 1425 } 1426 } 1427 else if ( result == kWaitListFileShareEvent ) 1428 { 1429 // File sharing changed 1430 1431 FileSharingDidChange( &gMDNSRecord ); 1432 1433 // and reset the event handler 1434 1435 if ((gFileSharingKey != NULL) && (gFileSharingChangedEvent)) 1436 { 1437 err = RegNotifyChangeKeyValue(gFileSharingKey, TRUE, REG_NOTIFY_CHANGE_NAME|REG_NOTIFY_CHANGE_LAST_SET, gFileSharingChangedEvent, TRUE); 1438 check_noerr( err ); 1439 } 1440 } 1441 else if ( result == kWaitListFirewallEvent ) 1442 { 1443 // Firewall configuration changed 1444 1445 FirewallDidChange( &gMDNSRecord ); 1446 1447 // and reset the event handler 1448 1449 if ((gFirewallKey != NULL) && (gFirewallChangedEvent)) 1450 { 1451 err = RegNotifyChangeKeyValue(gFirewallKey, TRUE, REG_NOTIFY_CHANGE_NAME|REG_NOTIFY_CHANGE_LAST_SET, gFirewallChangedEvent, TRUE); 1452 check_noerr( err ); 1453 } 1454 } 1455 else if ( result == kWaitListAdvertisedServicesEvent ) 1456 { 1457 // Ultimately we'll want to manage multiple services, but right now the only service 1458 // we'll be managing is SMB. 1459 1460 FileSharingDidChange( &gMDNSRecord ); 1461 1462 // and reset the event handler 1463 1464 if ( ( gAdvertisedServicesKey != NULL ) && ( gAdvertisedServicesChangedEvent ) ) 1465 { 1466 err = RegNotifyChangeKeyValue(gAdvertisedServicesKey, TRUE, REG_NOTIFY_CHANGE_NAME|REG_NOTIFY_CHANGE_LAST_SET, gAdvertisedServicesChangedEvent, TRUE); 1467 check_noerr( err ); 1468 } 1469 } 1470 else if ( result == kWaitListSPSWakeupEvent ) 1471 { 1472 LARGE_INTEGER timeout; 1473 1474 ReportStatus( EVENTLOG_INFORMATION_TYPE, "Maintenance wake" ); 1475 1476 timeout.QuadPart = kSPSMaintenanceWakePeriod; 1477 timeout.QuadPart *= kSecondsTo100NSUnits; 1478 1479 SetWaitableTimer( gSPSSleepEvent, &timeout, 0, NULL, NULL, TRUE ); 1480 } 1481 else if ( result == kWaitListSPSSleepEvent ) 1482 { 1483 ReportStatus( EVENTLOG_INFORMATION_TYPE, "Returning to sleep after maintenance wake" ); 1484 1485 // Calling SetSuspendState() doesn't invoke our sleep handlers, so we'll 1486 // call HandlePowerSuspend() explicity. This will reset the 1487 // maintenance wake timers. 1488 1489 HandlePowerSuspend( NULL ); 1490 SetSuspendState( FALSE, FALSE, FALSE ); 1491 } 1492 else 1493 { 1494 int waitItemIndex; 1495 1496 waitItemIndex = (int)( ( (int) result ) - WAIT_OBJECT_0 ); 1497 dlog( kDebugLevelChatty, DEBUG_NAME "waitable event on %d\n", waitItemIndex ); 1498 check( ( waitItemIndex >= 0 ) && ( waitItemIndex < waitListCount ) ); 1499 1500 if ( ( waitItemIndex >= 0 ) && ( waitItemIndex < waitListCount ) ) 1501 { 1502 HANDLE signaledEvent; 1503 int n = 0; 1504 1505 signaledEvent = waitList[ waitItemIndex ]; 1506 1507 // If gCurrentSource is not NULL, then this routine has been called 1508 // re-entrantly which should never happen. 1509 1510 check( !gCurrentSource ); 1511 1512 for ( gCurrentSource = gEventSourceList; gCurrentSource; ) 1513 { 1514 EventSource * current = gCurrentSource; 1515 1516 if ( gCurrentSource->event == signaledEvent ) 1517 { 1518 gCurrentSource->handler( &gMDNSRecord, gCurrentSource->event, gCurrentSource->context ); 1519 ++n; 1520 break; 1521 } 1522 1523 // If the current node was removed as a result of calling 1524 // the handler, then gCurrentSource was already incremented to 1525 // the next node. If it wasn't removed, then increment it 1526 // ourselves 1527 1528 if ( gCurrentSource == current ) 1529 { 1530 gCurrentSource = gCurrentSource->next; 1531 } 1532 } 1533 1534 gCurrentSource = NULL; 1535 1536 check( n > 0 ); 1537 } 1538 else 1539 { 1540 dlog( kDebugLevelWarning, DEBUG_NAME "%s: unexpected wait result (result=0x%08X)\n", __ROUTINE__, result ); 1541 } 1542 } 1543 } 1544 else 1545 { 1546 Sleep( 3 * 1000 ); 1547 1548 err = SetupInterfaceList( &gMDNSRecord ); 1549 check( !err ); 1550 1551 err = uDNS_SetupDNSConfig( &gMDNSRecord ); 1552 check( !err ); 1553 1554 break; 1555 } 1556 } 1557 1558 if ( waitList ) 1559 { 1560 free( waitList ); 1561 waitList = NULL; 1562 waitListCount = 0; 1563 } 1564 } 1565 1566 exit: 1567 1568 return( 0 ); 1569 } 1570 1571 //=========================================================================================================================== 1572 // ServiceSpecificStop 1573 //=========================================================================================================================== 1574 1575 static OSStatus ServiceSpecificStop( void ) 1576 { 1577 OSStatus err; 1578 BOOL ok; 1579 1580 ok = SetEvent(gStopEvent); 1581 err = translate_errno( ok, (OSStatus) GetLastError(), kUnknownErr ); 1582 require_noerr( err, exit ); 1583 exit: 1584 return( err ); 1585 } 1586 1587 //=========================================================================================================================== 1588 // ServiceSpecificFinalize 1589 //=========================================================================================================================== 1590 1591 static void ServiceSpecificFinalize( int argc, LPTSTR argv[] ) 1592 { 1593 DEBUG_UNUSED( argc ); 1594 DEBUG_UNUSED( argv ); 1595 1596 // 1597 // clean up any open sessions 1598 // 1599 while ( gEventSourceList ) 1600 { 1601 UnregisterWaitableEvent( &gMDNSRecord, gEventSourceList->event ); 1602 } 1603 1604 // 1605 // clean up the notifications 1606 // 1607 TearDownNotifications(); 1608 1609 // 1610 // clean up loaded library 1611 // 1612 1613 if( gIPHelperLibraryInstance ) 1614 { 1615 gGetIpInterfaceEntryFunctionPtr = NULL; 1616 1617 FreeLibrary( gIPHelperLibraryInstance ); 1618 gIPHelperLibraryInstance = NULL; 1619 } 1620 } 1621 1622 1623 //=========================================================================================================================== 1624 // SetupNotifications 1625 //=========================================================================================================================== 1626 1627 mDNSlocal mStatus SetupNotifications() 1628 { 1629 mStatus err; 1630 SocketRef sock; 1631 unsigned long param; 1632 int inBuffer; 1633 int outBuffer; 1634 DWORD outSize; 1635 1636 gStopEvent = CreateEvent(NULL, FALSE, FALSE, NULL); 1637 err = translate_errno( gStopEvent, errno_compat(), kNoResourcesErr ); 1638 require_noerr( err, exit ); 1639 1640 // Register to listen for address list changes. 1641 1642 gInterfaceListChangedEvent = CreateEvent( NULL, FALSE, FALSE, NULL ); 1643 err = translate_errno( gInterfaceListChangedEvent, (mStatus) GetLastError(), kUnknownErr ); 1644 require_noerr( err, exit ); 1645 1646 sock = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP ); 1647 err = translate_errno( IsValidSocket( sock ), errno_compat(), kUnknownErr ); 1648 require_noerr( err, exit ); 1649 gInterfaceListChangedSocket = sock; 1650 1651 // Make the socket non-blocking so the WSAIoctl returns immediately with WSAEWOULDBLOCK. It will set the event 1652 // when a change to the interface list is detected. 1653 1654 param = 1; 1655 err = ioctlsocket( sock, FIONBIO, ¶m ); 1656 err = translate_errno( err == 0, errno_compat(), kUnknownErr ); 1657 require_noerr( err, exit ); 1658 1659 inBuffer = 0; 1660 outBuffer = 0; 1661 err = WSAIoctl( sock, SIO_ADDRESS_LIST_CHANGE, &inBuffer, 0, &outBuffer, 0, &outSize, NULL, NULL ); 1662 if( err < 0 ) 1663 { 1664 check( errno_compat() == WSAEWOULDBLOCK ); 1665 } 1666 1667 err = WSAEventSelect( sock, gInterfaceListChangedEvent, FD_ADDRESS_LIST_CHANGE ); 1668 err = translate_errno( err == 0, errno_compat(), kUnknownErr ); 1669 require_noerr( err, exit ); 1670 1671 gDescChangedEvent = CreateEvent(NULL, TRUE, FALSE, NULL); 1672 err = translate_errno( gDescChangedEvent, (mStatus) GetLastError(), kUnknownErr ); 1673 require_noerr( err, exit ); 1674 1675 err = RegOpenKeyEx( HKEY_LOCAL_MACHINE, TEXT("SYSTEM\\CurrentControlSet\\Services\\lanmanserver\\parameters"), 0, KEY_READ, &gDescKey); 1676 check_translated_errno( err == 0, errno_compat(), kNameErr ); 1677 1678 if ( gDescKey != NULL ) 1679 { 1680 err = RegNotifyChangeKeyValue( gDescKey, TRUE, REG_NOTIFY_CHANGE_LAST_SET, gDescChangedEvent, TRUE); 1681 require_noerr( err, exit ); 1682 } 1683 1684 // This will catch all changes to tcp/ip networking, including changes to the domain search list 1685 1686 gTcpipChangedEvent = CreateEvent(NULL, FALSE, FALSE, NULL); 1687 err = translate_errno( gTcpipChangedEvent, (mStatus) GetLastError(), kUnknownErr ); 1688 require_noerr( err, exit ); 1689 1690 err = RegCreateKey( HKEY_LOCAL_MACHINE, TEXT("SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters"), &gTcpipKey ); 1691 require_noerr( err, exit ); 1692 1693 err = RegNotifyChangeKeyValue( gTcpipKey, TRUE, REG_NOTIFY_CHANGE_NAME|REG_NOTIFY_CHANGE_LAST_SET, gTcpipChangedEvent, TRUE); 1694 require_noerr( err, exit ); 1695 1696 // This will catch all changes to ddns configuration 1697 1698 gDdnsChangedEvent = CreateEvent(NULL, FALSE, FALSE, NULL); 1699 err = translate_errno( gDdnsChangedEvent, (mStatus) GetLastError(), kUnknownErr ); 1700 require_noerr( err, exit ); 1701 1702 err = RegCreateKey( HKEY_LOCAL_MACHINE, kServiceParametersNode TEXT("\\DynDNS\\Setup"), &gDdnsKey ); 1703 require_noerr( err, exit ); 1704 1705 err = RegNotifyChangeKeyValue( gDdnsKey, TRUE, REG_NOTIFY_CHANGE_NAME|REG_NOTIFY_CHANGE_LAST_SET, gDdnsChangedEvent, TRUE); 1706 require_noerr( err, exit ); 1707 1708 // This will catch all changes to file sharing 1709 1710 gFileSharingChangedEvent = CreateEvent( NULL, FALSE, FALSE, NULL ); 1711 err = translate_errno( gFileSharingChangedEvent, (mStatus) GetLastError(), kUnknownErr ); 1712 require_noerr( err, exit ); 1713 1714 err = RegCreateKey( HKEY_LOCAL_MACHINE, TEXT("SYSTEM\\CurrentControlSet\\Services\\lanmanserver\\Shares"), &gFileSharingKey ); 1715 1716 // Just to make sure that initialization doesn't fail on some old OS 1717 // that doesn't have this key, we'll only add the notification if 1718 // the key exists. 1719 1720 if ( !err ) 1721 { 1722 err = RegNotifyChangeKeyValue( gFileSharingKey, TRUE, REG_NOTIFY_CHANGE_NAME|REG_NOTIFY_CHANGE_LAST_SET, gFileSharingChangedEvent, TRUE); 1723 require_noerr( err, exit ); 1724 } 1725 else 1726 { 1727 err = mStatus_NoError; 1728 } 1729 1730 // This will catch changes to the Windows firewall 1731 1732 gFirewallChangedEvent = CreateEvent( NULL, FALSE, FALSE, NULL ); 1733 err = translate_errno( gFirewallChangedEvent, (mStatus) GetLastError(), kUnknownErr ); 1734 require_noerr( err, exit ); 1735 1736 // Just to make sure that initialization doesn't fail on some old OS 1737 // that doesn't have this key, we'll only add the notification if 1738 // the key exists. 1739 1740 err = RegCreateKey( HKEY_LOCAL_MACHINE, TEXT("SYSTEM\\CurrentControlSet\\Services\\SharedAccess\\Parameters\\FirewallPolicy\\FirewallRules"), &gFirewallKey ); 1741 1742 if ( !err ) 1743 { 1744 err = RegNotifyChangeKeyValue( gFirewallKey, TRUE, REG_NOTIFY_CHANGE_NAME|REG_NOTIFY_CHANGE_LAST_SET, gFirewallChangedEvent, TRUE); 1745 require_noerr( err, exit ); 1746 } 1747 else 1748 { 1749 err = mStatus_NoError; 1750 } 1751 1752 // This will catch all changes to advertised services configuration 1753 1754 gAdvertisedServicesChangedEvent = CreateEvent(NULL, FALSE, FALSE, NULL); 1755 err = translate_errno( gAdvertisedServicesChangedEvent, (mStatus) GetLastError(), kUnknownErr ); 1756 require_noerr( err, exit ); 1757 1758 err = RegCreateKey( HKEY_LOCAL_MACHINE, kServiceParametersNode TEXT("\\Services"), &gAdvertisedServicesKey ); 1759 require_noerr( err, exit ); 1760 1761 err = RegNotifyChangeKeyValue( gAdvertisedServicesKey, TRUE, REG_NOTIFY_CHANGE_NAME|REG_NOTIFY_CHANGE_LAST_SET, gAdvertisedServicesChangedEvent, TRUE); 1762 require_noerr( err, exit ); 1763 1764 gSPSWakeupEvent = CreateWaitableTimer( NULL, FALSE, NULL ); 1765 err = translate_errno( gSPSWakeupEvent, (mStatus) GetLastError(), kUnknownErr ); 1766 require_noerr( err, exit ); 1767 1768 gSPSSleepEvent = CreateWaitableTimer( NULL, FALSE, NULL ); 1769 err = translate_errno( gSPSSleepEvent, (mStatus) GetLastError(), kUnknownErr ); 1770 require_noerr( err, exit ); 1771 1772 gUDSEvent = CreateEvent( NULL, FALSE, FALSE, NULL ); 1773 err = translate_errno( gUDSEvent, ( mStatus ) GetLastError(), kUnknownErr ); 1774 require_noerr( err, exit ); 1775 1776 exit: 1777 if( err ) 1778 { 1779 TearDownNotifications(); 1780 } 1781 return( err ); 1782 } 1783 1784 //=========================================================================================================================== 1785 // TearDownNotifications 1786 //=========================================================================================================================== 1787 1788 mDNSlocal mStatus TearDownNotifications() 1789 { 1790 if ( gStopEvent ) 1791 { 1792 CloseHandle( gStopEvent ); 1793 gStopEvent = NULL; 1794 } 1795 1796 if( IsValidSocket( gInterfaceListChangedSocket ) ) 1797 { 1798 close_compat( gInterfaceListChangedSocket ); 1799 gInterfaceListChangedSocket = kInvalidSocketRef; 1800 } 1801 1802 if( gInterfaceListChangedEvent ) 1803 { 1804 CloseHandle( gInterfaceListChangedEvent ); 1805 gInterfaceListChangedEvent = 0; 1806 } 1807 1808 if ( gDescChangedEvent != NULL ) 1809 { 1810 CloseHandle( gDescChangedEvent ); 1811 gDescChangedEvent = NULL; 1812 } 1813 1814 if ( gDescKey != NULL ) 1815 { 1816 RegCloseKey( gDescKey ); 1817 gDescKey = NULL; 1818 } 1819 1820 if ( gTcpipChangedEvent != NULL ) 1821 { 1822 CloseHandle( gTcpipChangedEvent ); 1823 gTcpipChangedEvent = NULL; 1824 } 1825 1826 if ( gDdnsChangedEvent != NULL ) 1827 { 1828 CloseHandle( gDdnsChangedEvent ); 1829 gDdnsChangedEvent = NULL; 1830 } 1831 1832 if ( gDdnsKey != NULL ) 1833 { 1834 RegCloseKey( gDdnsKey ); 1835 gDdnsKey = NULL; 1836 } 1837 1838 if ( gFileSharingChangedEvent != NULL ) 1839 { 1840 CloseHandle( gFileSharingChangedEvent ); 1841 gFileSharingChangedEvent = NULL; 1842 } 1843 1844 if ( gFileSharingKey != NULL ) 1845 { 1846 RegCloseKey( gFileSharingKey ); 1847 gFileSharingKey = NULL; 1848 } 1849 1850 if ( gFirewallChangedEvent != NULL ) 1851 { 1852 CloseHandle( gFirewallChangedEvent ); 1853 gFirewallChangedEvent = NULL; 1854 } 1855 1856 if ( gFirewallKey != NULL ) 1857 { 1858 RegCloseKey( gFirewallKey ); 1859 gFirewallKey = NULL; 1860 } 1861 1862 if ( gAdvertisedServicesChangedEvent != NULL ) 1863 { 1864 CloseHandle( gAdvertisedServicesChangedEvent ); 1865 gAdvertisedServicesChangedEvent = NULL; 1866 } 1867 1868 if ( gAdvertisedServicesKey != NULL ) 1869 { 1870 RegCloseKey( gAdvertisedServicesKey ); 1871 gAdvertisedServicesKey = NULL; 1872 } 1873 1874 if ( gSPSWakeupEvent ) 1875 { 1876 CloseHandle( gSPSWakeupEvent ); 1877 gSPSWakeupEvent = NULL; 1878 } 1879 1880 if ( gSPSSleepEvent ) 1881 { 1882 CloseHandle( gSPSSleepEvent ); 1883 gSPSSleepEvent = NULL; 1884 } 1885 1886 return( mStatus_NoError ); 1887 } 1888 1889 1890 //=========================================================================================================================== 1891 // RegisterWaitableEvent 1892 //=========================================================================================================================== 1893 1894 static mStatus RegisterWaitableEvent( mDNS * const inMDNS, HANDLE event, void * context, RegisterWaitableEventHandler handler ) 1895 { 1896 EventSource * source; 1897 mStatus err = mStatus_NoError; 1898 1899 ( void ) inMDNS; 1900 check( event ); 1901 check( handler ); 1902 1903 source = ( EventSource* ) malloc( sizeof( EventSource ) ); 1904 require_action( source, exit, err = mStatus_NoMemoryErr ); 1905 mDNSPlatformMemZero( source, sizeof( EventSource ) ); 1906 source->event = event; 1907 source->context = context; 1908 source->handler = handler; 1909 1910 source->next = gEventSourceList; 1911 gEventSourceList = source; 1912 gEventSourceListChanged = TRUE; 1913 gEventSources++; 1914 1915 exit: 1916 1917 return err; 1918 } 1919 1920 1921 //=========================================================================================================================== 1922 // UnregisterWaitableEvent 1923 //=========================================================================================================================== 1924 1925 static void UnregisterWaitableEvent( mDNS * const inMDNS, HANDLE event ) 1926 { 1927 EventSource * current = gEventSourceList; 1928 EventSource * last = NULL; 1929 1930 ( void ) inMDNS; 1931 check( event ); 1932 1933 while ( current ) 1934 { 1935 if ( current->event == event ) 1936 { 1937 if ( last == NULL ) 1938 { 1939 gEventSourceList = current->next; 1940 } 1941 else 1942 { 1943 last->next = current->next; 1944 } 1945 1946 gEventSourceListChanged = TRUE; 1947 1948 // Protect against removing the node that we happen 1949 // to be looking at as we iterate through the event 1950 // source list in ServiceSpecificRun() 1951 1952 if ( current == gCurrentSource ) 1953 { 1954 gCurrentSource = current->next; 1955 } 1956 1957 gEventSources--; 1958 free( current ); 1959 1960 break; 1961 } 1962 1963 last = current; 1964 current = current->next; 1965 } 1966 } 1967 1968 1969 //=========================================================================================================================== 1970 // SetupWaitList 1971 //=========================================================================================================================== 1972 1973 mDNSlocal mStatus SetupWaitList( mDNS * const inMDNS, HANDLE **outWaitList, int *outWaitListCount ) 1974 { 1975 int waitListCount; 1976 HANDLE * waitList; 1977 HANDLE * waitItemPtr; 1978 EventSource * source; 1979 mStatus err; 1980 1981 dlog( kDebugLevelTrace, DEBUG_NAME "setting up wait list\n" ); 1982 1983 ( void ) inMDNS; 1984 check( inMDNS->p ); 1985 check( outWaitList ); 1986 check( outWaitListCount ); 1987 1988 // Allocate an array to hold all the objects to wait on. 1989 1990 waitListCount = kWaitListFixedItemCount + gEventSources; 1991 waitList = ( HANDLE* ) malloc( waitListCount * sizeof( *waitList ) ); 1992 require_action( waitList, exit, err = mStatus_NoMemoryErr ); 1993 waitItemPtr = waitList; 1994 1995 // Add the fixed wait items to the beginning of the list. 1996 1997 *waitItemPtr++ = gStopEvent; 1998 *waitItemPtr++ = gInterfaceListChangedEvent; 1999 *waitItemPtr++ = gDescChangedEvent; 2000 *waitItemPtr++ = gTcpipChangedEvent; 2001 *waitItemPtr++ = gDdnsChangedEvent; 2002 *waitItemPtr++ = gFileSharingChangedEvent; 2003 *waitItemPtr++ = gFirewallChangedEvent; 2004 *waitItemPtr++ = gAdvertisedServicesChangedEvent; 2005 *waitItemPtr++ = gSPSWakeupEvent; 2006 *waitItemPtr++ = gSPSSleepEvent; 2007 2008 for ( source = gEventSourceList; source; source = source->next ) 2009 { 2010 *waitItemPtr++ = source->event; 2011 } 2012 2013 check( ( int )( waitItemPtr - waitList ) == waitListCount ); 2014 2015 *outWaitList = waitList; 2016 *outWaitListCount = waitListCount; 2017 waitList = NULL; 2018 err = mStatus_NoError; 2019 2020 exit: 2021 2022 if( waitList ) 2023 { 2024 free( waitList ); 2025 } 2026 2027 dlog( kDebugLevelTrace, DEBUG_NAME "setting up wait list done (err=%d %m)\n", err, err ); 2028 return( err ); 2029 } 2030 2031 2032 //=========================================================================================================================== 2033 // CoreCallback 2034 //=========================================================================================================================== 2035 2036 static void 2037 CoreCallback(mDNS * const inMDNS, mStatus status) 2038 { 2039 if (status == mStatus_ConfigChanged) 2040 { 2041 SetLLRoute( inMDNS ); 2042 } 2043 } 2044 2045 2046 //=========================================================================================================================== 2047 // UDSCanAccept 2048 //=========================================================================================================================== 2049 2050 mDNSlocal void UDSCanAccept( mDNS * const inMDNS, HANDLE event, void * context ) 2051 { 2052 ( void ) inMDNS; 2053 ( void ) event; 2054 2055 if ( gUDSCallback ) 2056 { 2057 gUDSCallback( ( int ) gUDSSocket, 0, context ); 2058 } 2059 } 2060 2061 2062 //=========================================================================================================================== 2063 // UDSCanRead 2064 //=========================================================================================================================== 2065 2066 mDNSlocal void UDSCanRead( TCPSocket * sock ) 2067 { 2068 udsEventCallback callback = ( udsEventCallback ) sock->userCallback; 2069 2070 if ( callback ) 2071 { 2072 callback( (int) sock->fd, 0, sock->userContext ); 2073 } 2074 } 2075 2076 2077 //=========================================================================================================================== 2078 // udsSupportAddFDToEventLoop 2079 //=========================================================================================================================== 2080 2081 2082 mStatus 2083 udsSupportAddFDToEventLoop( SocketRef fd, udsEventCallback callback, void *context, void **platform_data) 2084 { 2085 mStatus err = mStatus_NoError; 2086 2087 // We are using some knowledge of what is being passed to us here. If the fd is a listen socket, 2088 // then the "callback" parameter is NULL. If it is an actual read/write socket, then the "callback" 2089 // parameter is not null. This is important because we use waitable events for the listen socket 2090 // and alertable I/O for the read/write sockets. 2091 2092 if ( context ) 2093 { 2094 TCPSocket * sock; 2095 2096 sock = malloc( sizeof( TCPSocket ) ); 2097 require_action( sock, exit, err = mStatus_NoMemoryErr ); 2098 mDNSPlatformMemZero( sock, sizeof( TCPSocket ) ); 2099 2100 sock->fd = (SOCKET) fd; 2101 sock->readEventHandler = UDSCanRead; 2102 sock->userCallback = callback; 2103 sock->userContext = context; 2104 sock->m = &gMDNSRecord; 2105 2106 err = TCPAddSocket( sock->m, sock ); 2107 require_noerr( err, exit ); 2108 2109 *platform_data = sock; 2110 } 2111 else 2112 { 2113 gUDSSocket = fd; 2114 gUDSCallback = callback; 2115 gUDSEvent = CreateEvent( NULL, FALSE, FALSE, NULL ); 2116 err = translate_errno( gUDSEvent, (mStatus) GetLastError(), kUnknownErr ); 2117 require_noerr( err, exit ); 2118 err = WSAEventSelect( fd, gUDSEvent, FD_ACCEPT | FD_CLOSE ); 2119 err = translate_errno( err == 0, WSAGetLastError(), kNoResourcesErr ); 2120 require_noerr( err, exit ); 2121 err = RegisterWaitableEvent( &gMDNSRecord, gUDSEvent, context, UDSCanAccept ); 2122 require_noerr( err, exit ); 2123 } 2124 2125 exit: 2126 2127 return err; 2128 } 2129 2130 2131 int 2132 udsSupportReadFD( SocketRef fd, char *buf, int len, int flags, void *platform_data ) 2133 { 2134 TCPSocket * sock; 2135 mDNSBool closed; 2136 int ret; 2137 2138 ( void ) flags; 2139 2140 sock = ( TCPSocket* ) platform_data; 2141 require_action( sock, exit, ret = -1 ); 2142 require_action( sock->fd == fd, exit, ret = -1 ); 2143 2144 ret = mDNSPlatformReadTCP( sock, buf, len, &closed ); 2145 2146 if ( closed ) 2147 { 2148 ret = 0; 2149 } 2150 2151 exit: 2152 2153 return ret; 2154 } 2155 2156 2157 mStatus 2158 udsSupportRemoveFDFromEventLoop( SocketRef fd, void *platform_data) // Note: This also CLOSES the socket 2159 { 2160 mStatus err = kNoErr; 2161 2162 if ( platform_data != NULL ) 2163 { 2164 TCPSocket * sock; 2165 2166 dlog( kDebugLevelInfo, DEBUG_NAME "session closed\n" ); 2167 sock = ( TCPSocket* ) platform_data; 2168 check( sock->fd == fd ); 2169 mDNSPlatformTCPCloseConnection( sock ); 2170 } 2171 else if ( gUDSEvent != NULL ) 2172 { 2173 UnregisterWaitableEvent( &gMDNSRecord, gUDSEvent ); 2174 WSAEventSelect( fd, gUDSEvent, 0 ); 2175 CloseHandle( gUDSEvent ); 2176 gUDSEvent = NULL; 2177 } 2178 2179 return err; 2180 } 2181 2182 2183 mDNSexport void RecordUpdatedNiceLabel(mDNS *const m, mDNSs32 delay) 2184 { 2185 (void)m; 2186 (void)delay; 2187 // No-op, for now 2188 } 2189 2190 2191 //=========================================================================================================================== 2192 // SystemWakeForNetworkAccess 2193 //=========================================================================================================================== 2194 2195 mDNSu8 2196 SystemWakeForNetworkAccess( LARGE_INTEGER * timeout ) 2197 { 2198 HKEY key = NULL; 2199 DWORD dwSize; 2200 DWORD enabled; 2201 mDNSu8 ok; 2202 SYSTEM_POWER_STATUS powerStatus; 2203 time_t startTime; 2204 time_t nextWakeupTime; 2205 int delta; 2206 DWORD err; 2207 2208 dlog( kDebugLevelInfo, DEBUG_NAME "SystemWakeForNetworkAccess\n" ); 2209 2210 // Make sure we have a timer 2211 2212 require_action( gSPSWakeupEvent != NULL, exit, ok = FALSE ); 2213 require_action( gSPSSleepEvent != NULL, exit, ok = FALSE ); 2214 2215 // Make sure the user enabled bonjour sleep proxy client 2216 2217 err = RegCreateKey( HKEY_LOCAL_MACHINE, kServiceParametersNode L"\\Power Management", &key ); 2218 require_action( !err, exit, ok = FALSE ); 2219 dwSize = sizeof( DWORD ); 2220 err = RegQueryValueEx( key, L"Enabled", NULL, NULL, (LPBYTE) &enabled, &dwSize ); 2221 require_action( !err, exit, ok = FALSE ); 2222 require_action( enabled, exit, ok = FALSE ); 2223 2224 // Make sure machine is on AC power 2225 2226 ok = ( mDNSu8 ) GetSystemPowerStatus( &powerStatus ); 2227 require_action( ok, exit, ok = FALSE ); 2228 require_action( powerStatus.ACLineStatus == AC_LINE_ONLINE, exit, ok = FALSE ); 2229 2230 // Now make sure we have a network interface that does wake-on-lan 2231 2232 ok = ( mDNSu8 ) IsWOMPEnabled( &gMDNSRecord ); 2233 require_action( ok, exit, ok = FALSE ); 2234 2235 // Now make sure we have advertised services. Doesn't make sense to 2236 // enable sleep proxy if we have no multicast services that could 2237 // potentially wake us up. 2238 2239 ok = ( mDNSu8 ) mDNSCoreHaveAdvertisedMulticastServices( &gMDNSRecord ); 2240 require_action( ok, exit, ok = FALSE ); 2241 2242 // Calculate next wake up time 2243 2244 startTime = time( NULL ); // Seconds since midnight January 1, 1970 2245 nextWakeupTime = startTime + ( 120 * 60 ); // 2 hours later 2246 2247 if ( gMDNSRecord.p->nextDHCPLeaseExpires < nextWakeupTime ) 2248 { 2249 nextWakeupTime = gMDNSRecord.p->nextDHCPLeaseExpires; 2250 } 2251 2252 // Finally calculate the next relative wakeup time 2253 2254 delta = ( int )( ( ( double )( nextWakeupTime - startTime ) ) * 0.9 ); 2255 ReportStatus( EVENTLOG_INFORMATION_TYPE, "enabling sleep proxy client with next maintenance wake in %d seconds", delta ); 2256 2257 // Convert seconds to 100 nanosecond units expected by SetWaitableTimer 2258 2259 timeout->QuadPart = -delta; 2260 timeout->QuadPart *= kSecondsTo100NSUnits; 2261 2262 ok = TRUE; 2263 2264 exit: 2265 2266 if ( key ) 2267 { 2268 RegCloseKey( key ); 2269 } 2270 2271 return ok; 2272 } 2273 2274 2275 //=========================================================================================================================== 2276 // HaveRoute 2277 //=========================================================================================================================== 2278 2279 static bool 2280 HaveRoute( PMIB_IPFORWARDROW rowExtant, unsigned long addr, unsigned long metric ) 2281 { 2282 PMIB_IPFORWARDTABLE pIpForwardTable = NULL; 2283 DWORD dwSize = 0; 2284 BOOL bOrder = FALSE; 2285 OSStatus err; 2286 bool found = false; 2287 unsigned long int i; 2288 2289 // 2290 // Find out how big our buffer needs to be. 2291 // 2292 err = GetIpForwardTable(NULL, &dwSize, bOrder); 2293 require_action( err == ERROR_INSUFFICIENT_BUFFER, exit, err = kUnknownErr ); 2294 2295 // 2296 // Allocate the memory for the table 2297 // 2298 pIpForwardTable = (PMIB_IPFORWARDTABLE) malloc( dwSize ); 2299 require_action( pIpForwardTable, exit, err = kNoMemoryErr ); 2300 2301 // 2302 // Now get the table. 2303 // 2304 err = GetIpForwardTable(pIpForwardTable, &dwSize, bOrder); 2305 require_noerr( err, exit ); 2306 2307 // 2308 // Search for the row in the table we want. 2309 // 2310 for ( i = 0; i < pIpForwardTable->dwNumEntries; i++) 2311 { 2312 if ( ( pIpForwardTable->table[i].dwForwardDest == addr ) && ( !metric || ( pIpForwardTable->table[i].dwForwardMetric1 == metric ) ) ) 2313 { 2314 memcpy( rowExtant, &(pIpForwardTable->table[i]), sizeof(*rowExtant) ); 2315 found = true; 2316 break; 2317 } 2318 } 2319 2320 exit: 2321 2322 if ( pIpForwardTable != NULL ) 2323 { 2324 free(pIpForwardTable); 2325 } 2326 2327 return found; 2328 } 2329 2330 2331 //=========================================================================================================================== 2332 // IsValidAddress 2333 //=========================================================================================================================== 2334 2335 static bool 2336 IsValidAddress( const char * addr ) 2337 { 2338 return ( addr && ( strcmp( addr, "0.0.0.0" ) != 0 ) ) ? true : false; 2339 } 2340 2341 2342 //=========================================================================================================================== 2343 // GetAdditionalMetric 2344 //=========================================================================================================================== 2345 2346 static ULONG 2347 GetAdditionalMetric( DWORD ifIndex ) 2348 { 2349 ULONG metric = 0; 2350 2351 if( !gIPHelperLibraryInstance ) 2352 { 2353 gIPHelperLibraryInstance = LoadLibrary( TEXT( "Iphlpapi" ) ); 2354 2355 gGetIpInterfaceEntryFunctionPtr = 2356 (GetIpInterfaceEntryFunctionPtr) GetProcAddress( gIPHelperLibraryInstance, "GetIpInterfaceEntry" ); 2357 2358 if( !gGetIpInterfaceEntryFunctionPtr ) 2359 { 2360 BOOL ok; 2361 2362 ok = FreeLibrary( gIPHelperLibraryInstance ); 2363 check_translated_errno( ok, GetLastError(), kUnknownErr ); 2364 gIPHelperLibraryInstance = NULL; 2365 } 2366 } 2367 2368 if ( gGetIpInterfaceEntryFunctionPtr ) 2369 { 2370 MIB_IPINTERFACE_ROW row; 2371 DWORD err; 2372 2373 ZeroMemory( &row, sizeof( MIB_IPINTERFACE_ROW ) ); 2374 row.Family = AF_INET; 2375 row.InterfaceIndex = ifIndex; 2376 err = gGetIpInterfaceEntryFunctionPtr( &row ); 2377 require_noerr( err, exit ); 2378 metric = row.Metric + 256; 2379 } 2380 2381 exit: 2382 2383 return metric; 2384 } 2385 2386 2387 //=========================================================================================================================== 2388 // SetLLRoute 2389 //=========================================================================================================================== 2390 2391 static OSStatus 2392 SetLLRoute( mDNS * const inMDNS ) 2393 { 2394 OSStatus err = kNoErr; 2395 2396 DEBUG_UNUSED( inMDNS ); 2397 2398 // 2399 // <rdar://problem/4096464> Don't call SetLLRoute on loopback 2400 // <rdar://problem/6885843> Default route on Windows 7 breaks network connectivity 2401 // 2402 // Don't mess w/ the routing table on Vista and later OSes, as 2403 // they have a permanent route to link-local addresses. Otherwise, 2404 // set a route to link local addresses (169.254.0.0) 2405 // 2406 if ( ( gOSMajorVersion < 6 ) && gServiceManageLLRouting && !gPlatformStorage.registeredLoopback4 ) 2407 { 2408 DWORD ifIndex; 2409 MIB_IPFORWARDROW rowExtant; 2410 bool addRoute; 2411 MIB_IPFORWARDROW row; 2412 2413 ZeroMemory(&row, sizeof(row)); 2414 2415 err = GetRouteDestination(&ifIndex, &row.dwForwardNextHop); 2416 require_noerr( err, exit ); 2417 row.dwForwardDest = inet_addr(kLLNetworkAddr); 2418 row.dwForwardIfIndex = ifIndex; 2419 row.dwForwardMask = inet_addr(kLLNetworkAddrMask); 2420 row.dwForwardType = 3; 2421 row.dwForwardProto = MIB_IPPROTO_NETMGMT; 2422 row.dwForwardAge = 0; 2423 row.dwForwardPolicy = 0; 2424 row.dwForwardMetric1 = 20 + GetAdditionalMetric( ifIndex ); 2425 row.dwForwardMetric2 = (DWORD) - 1; 2426 row.dwForwardMetric3 = (DWORD) - 1; 2427 row.dwForwardMetric4 = (DWORD) - 1; 2428 row.dwForwardMetric5 = (DWORD) - 1; 2429 2430 addRoute = true; 2431 2432 // 2433 // check to make sure we don't already have a route 2434 // 2435 if ( HaveRoute( &rowExtant, inet_addr( kLLNetworkAddr ), 0 ) ) 2436 { 2437 // 2438 // set the age to 0 so that we can do a memcmp. 2439 // 2440 rowExtant.dwForwardAge = 0; 2441 2442 // 2443 // check to see if this route is the same as our route 2444 // 2445 if (memcmp(&row, &rowExtant, sizeof(row)) != 0) 2446 { 2447 // 2448 // if it isn't then delete this entry 2449 // 2450 DeleteIpForwardEntry(&rowExtant); 2451 } 2452 else 2453 { 2454 // 2455 // else it is, so we don't want to create another route 2456 // 2457 addRoute = false; 2458 } 2459 } 2460 2461 if (addRoute && row.dwForwardNextHop) 2462 { 2463 err = CreateIpForwardEntry(&row); 2464 check_noerr( err ); 2465 } 2466 } 2467 2468 exit: 2469 2470 return ( err ); 2471 } 2472 2473 2474 //=========================================================================================================================== 2475 // GetRouteDestination 2476 //=========================================================================================================================== 2477 2478 static OSStatus 2479 GetRouteDestination(DWORD * ifIndex, DWORD * address) 2480 { 2481 struct in_addr ia; 2482 IP_ADAPTER_INFO * pAdapterInfo = NULL; 2483 IP_ADAPTER_INFO * pAdapter = NULL; 2484 ULONG bufLen; 2485 mDNSBool done = mDNSfalse; 2486 OSStatus err; 2487 2488 // 2489 // GetBestInterface will fail if there is no default gateway 2490 // configured. If that happens, we will just take the first 2491 // interface in the list. MSDN support says there is no surefire 2492 // way to manually determine what the best interface might 2493 // be for a particular network address. 2494 // 2495 ia.s_addr = inet_addr(kLLNetworkAddr); 2496 err = GetBestInterface(*(IPAddr*) &ia, ifIndex); 2497 2498 if (err) 2499 { 2500 *ifIndex = 0; 2501 } 2502 2503 // 2504 // Make an initial call to GetAdaptersInfo to get 2505 // the necessary size into the bufLen variable 2506 // 2507 err = GetAdaptersInfo( NULL, &bufLen); 2508 require_action( err == ERROR_BUFFER_OVERFLOW, exit, err = kUnknownErr ); 2509 2510 pAdapterInfo = (IP_ADAPTER_INFO*) malloc( bufLen ); 2511 require_action( pAdapterInfo, exit, err = kNoMemoryErr ); 2512 2513 err = GetAdaptersInfo( pAdapterInfo, &bufLen); 2514 require_noerr( err, exit ); 2515 2516 pAdapter = pAdapterInfo; 2517 err = kUnknownErr; 2518 2519 // <rdar://problem/3718122> 2520 // <rdar://problem/5652098> 2521 // 2522 // Look for the Nortel VPN virtual interface, along with Juniper virtual interface. 2523 // 2524 // If these interfaces are active (i.e., has a non-zero IP Address), 2525 // then we want to disable routing table modifications. 2526 2527 while (pAdapter) 2528 { 2529 if ( ( IsNortelVPN( pAdapter ) || IsJuniperVPN( pAdapter ) || IsCiscoVPN( pAdapter ) ) && 2530 ( inet_addr( pAdapter->IpAddressList.IpAddress.String ) != 0 ) ) 2531 { 2532 dlog( kDebugLevelTrace, DEBUG_NAME "disabling routing table management due to VPN incompatibility" ); 2533 goto exit; 2534 } 2535 2536 pAdapter = pAdapter->Next; 2537 } 2538 2539 while ( !done ) 2540 { 2541 pAdapter = pAdapterInfo; 2542 err = kUnknownErr; 2543 2544 while (pAdapter) 2545 { 2546 // If we don't have an interface selected, choose the first one that is of type ethernet and 2547 // has a valid IP Address 2548 2549 if ((pAdapter->Type == MIB_IF_TYPE_ETHERNET) && ( IsValidAddress( pAdapter->IpAddressList.IpAddress.String ) ) && (!(*ifIndex) || (pAdapter->Index == (*ifIndex)))) 2550 { 2551 *address = inet_addr( pAdapter->IpAddressList.IpAddress.String ); 2552 *ifIndex = pAdapter->Index; 2553 err = kNoErr; 2554 break; 2555 } 2556 2557 pAdapter = pAdapter->Next; 2558 } 2559 2560 // If we found the right interface, or we weren't trying to find a specific interface then we're done 2561 2562 if ( !err || !( *ifIndex) ) 2563 { 2564 done = mDNStrue; 2565 } 2566 2567 // Otherwise, try again by wildcarding the interface 2568 2569 else 2570 { 2571 *ifIndex = 0; 2572 } 2573 } 2574 2575 exit: 2576 2577 if ( pAdapterInfo != NULL ) 2578 { 2579 free( pAdapterInfo ); 2580 } 2581 2582 return( err ); 2583 } 2584 2585 2586 static bool 2587 IsNortelVPN( IP_ADAPTER_INFO * pAdapter ) 2588 { 2589 return ((pAdapter->Type == MIB_IF_TYPE_ETHERNET) && 2590 (pAdapter->AddressLength == 6) && 2591 (pAdapter->Address[0] == 0x44) && 2592 (pAdapter->Address[1] == 0x45) && 2593 (pAdapter->Address[2] == 0x53) && 2594 (pAdapter->Address[3] == 0x54) && 2595 (pAdapter->Address[4] == 0x42) && 2596 (pAdapter->Address[5] == 0x00)) ? true : false; 2597 } 2598 2599 2600 static bool 2601 IsJuniperVPN( IP_ADAPTER_INFO * pAdapter ) 2602 { 2603 return ( strnistr( pAdapter->Description, "Juniper", sizeof( pAdapter->Description ) ) != NULL ) ? true : false; 2604 } 2605 2606 2607 static bool 2608 IsCiscoVPN( IP_ADAPTER_INFO * pAdapter ) 2609 { 2610 return ((pAdapter->Type == MIB_IF_TYPE_ETHERNET) && 2611 (pAdapter->AddressLength == 6) && 2612 (pAdapter->Address[0] == 0x00) && 2613 (pAdapter->Address[1] == 0x05) && 2614 (pAdapter->Address[2] == 0x9a) && 2615 (pAdapter->Address[3] == 0x3c) && 2616 (pAdapter->Address[4] == 0x7a) && 2617 (pAdapter->Address[5] == 0x00)) ? true : false; 2618 } 2619 2620 2621 static const char * 2622 strnistr( const char * string, const char * subString, size_t max ) 2623 { 2624 size_t subStringLen; 2625 size_t offset; 2626 size_t maxOffset; 2627 size_t stringLen; 2628 const char * pPos; 2629 2630 if ( ( string == NULL ) || ( subString == NULL ) ) 2631 { 2632 return string; 2633 } 2634 2635 stringLen = ( max > strlen( string ) ) ? strlen( string ) : max; 2636 2637 if ( stringLen == 0 ) 2638 { 2639 return NULL; 2640 } 2641 2642 subStringLen = strlen( subString ); 2643 2644 if ( subStringLen == 0 ) 2645 { 2646 return string; 2647 } 2648 2649 if ( subStringLen > stringLen ) 2650 { 2651 return NULL; 2652 } 2653 2654 maxOffset = stringLen - subStringLen; 2655 pPos = string; 2656 2657 for ( offset = 0; offset <= maxOffset; offset++ ) 2658 { 2659 if ( _strnicmp( pPos, subString, subStringLen ) == 0 ) 2660 { 2661 return pPos; 2662 } 2663 2664 pPos++; 2665 } 2666 2667 return NULL; 2668 } 2669 2670
