#ifdef __WIN_SERVICE__ 
  
 #include "hbapi.h" 
 #include "hbapiitm.h" 
 #include "hbvm.h" 
 //#include "hbxvm.h" 
 //#include "hbset.h" 
 //#include "hbthread.h" 
 #include "srvleto.h" 
  
 #define _SERVICE_NAME            "LetoDB_Service" 
 #define _SERVICE_DISPLAY_NAME    "LetoDB Service" 
  
 #define _SERVICE_DESCRIPTION     "Leto DB Server is a multiplatform database server or a database management system, chiefly intended for client programs, written on Harbour."   // BAA 
  
 static SERVICE_STATUS_HANDLE     hServiceHandle = 0; 
 static char                      ServiceEntryFunc[ HB_SYMBOL_NAME_LEN + 1 ]; 
  
  
  
 // BAA static TCHAR                     ServiceName[]        = _SERVICE_NAME; 
 // BAA static TCHAR                     ServiceDisplayName[] = _SERVICE_DISPLAY_NAME; 
  
  
 // BAA  
 static TCHAR                     ServiceName[64]; 
 static TCHAR                     ServiceDisplayName[64];  
 static TCHAR                     ServiceDescription[] = _SERVICE_DESCRIPTION; 
 // BAA 
  
  
 extern int leto_GlobalExit; 
  
 static ULONG ulSvcError = 0; 
  
  
 void leto_SetServiceStatus( DWORD State ) 
 { 
    SERVICE_STATUS SrvStatus; 
  
    SrvStatus.dwServiceType             = SERVICE_WIN32_OWN_PROCESS; 
    SrvStatus.dwCurrentState            = State; 
    SrvStatus.dwControlsAccepted        = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN; 
    SrvStatus.dwWin32ExitCode           = 0; 
    SrvStatus.dwServiceSpecificExitCode = 0; 
    SrvStatus.dwCheckPoint              = 0; 
    SrvStatus.dwWaitHint                = 0; 
  
    if( hServiceHandle ) 
       SetServiceStatus( hServiceHandle, &SrvStatus ); 
 } 
  
 void WINAPI leto_ServiceControlHandler( DWORD dwCtrlCode ) 
 { 
    DWORD State = SERVICE_RUNNING; 
  
    switch( dwCtrlCode ) 
    { 
       case SERVICE_CONTROL_STOP: 
          State = SERVICE_STOPPED; 
          leto_GlobalExit = 1; 
          return;                        // BAA - ???  Probably break; 
  
       case SERVICE_CONTROL_SHUTDOWN: 
          State = SERVICE_STOPPED; 
          leto_GlobalExit = 1; 
          return;                       // BAA - ???  Probably break; 
    } 
  
    leto_SetServiceStatus( State ); 
 } 
  
 void WINAPI leto_ServiceMainFunction( DWORD dwArgc, LPTSTR * lpszArgv ) 
 { 
    HB_SYMBOL_UNUSED( dwArgc ); 
    HB_SYMBOL_UNUSED( lpszArgv ); 
  
    hServiceHandle = RegisterServiceCtrlHandler( ServiceName, ( LPHANDLER_FUNCTION ) leto_ServiceControlHandler ); 
  
    if( hServiceHandle != (SERVICE_STATUS_HANDLE) 0 ) 
    { 
       PHB_DYNS pDynSym; 
  
       leto_SetServiceStatus( SERVICE_RUNNING ); 
  
       hb_vmThreadInit( NULL ); 
  
       pDynSym = hb_dynsymFindName( ServiceEntryFunc ); 
  
       if( pDynSym ) 
       { 
           if( hb_vmRequestReenter() ) 
          { 
             hb_vmPushSymbol( hb_dynsymSymbol( pDynSym ) ); 
             hb_vmPushNil(); 
             hb_vmProc( 0 ); 
  
             hb_vmRequestRestore(); 
          } 
       } 
  
       leto_SetServiceStatus( SERVICE_STOPPED ); 
  
       hb_vmThreadQuit(); 
    } 
 } 
  
  
 // BAA - New function 
  
 static DWORD leto_GetNameService( TCHAR *szBuf)  
 { 
   DWORD sz, i; 
   TCHAR *ptr; 
   
   sz = GetModuleFileName( NULL, szBuf, MAX_PATH ); 
  
   if( sz > 0) 
   { 
     // BAA :  ServiceName == ExecName without Extendet. 
  
     ptr = &szBuf[sz]; while( *ptr != 0x5C ) ptr--;       // BAA 0x5C == '\' 
  
     ptr++; i = 0;      
     while( *ptr != '.'  ) 
     { 
        ServiceDisplayName[ i ] = *ptr; 
        ServiceName[ i++ ]      = *ptr++; 
     } 
     ServiceName[ i ] = 0; 
     ServiceDisplayName[ i++ ] = ' '; 
  
     strcpy( &ServiceDisplayName[ i ], "Service" ); 
        
   } 
   return sz; 
 } 
  
 HB_FUNC( LETO_SERVICESTART ) 
 { 
    DWORD n; 
    TCHAR szPath[ MAX_PATH ]; 
    HB_BOOL bRetVal = HB_FALSE; 
  
    SERVICE_TABLE_ENTRY lpServiceTable[ 2 ] = { { ServiceName, ( LPSERVICE_MAIN_FUNCTION ) leto_ServiceMainFunction }, 
                                                { NULL, NULL } }; 
  
    leto_GetNameService( szPath );   // BAA - define ServiceName, ... 
  
    // hb_strncpy( ServiceEntryFunc, hb_parcx( 1 ), HB_SIZEOFARRAY( ServiceEntryFunc ) - 1 ); 
  
    // BAA  
    n = hb_parclen(1);  
    memcpy( ServiceEntryFunc, hb_parc(1), n); 
    ServiceEntryFunc[n] = 0; 
  
  
  
    if( StartServiceCtrlDispatcher( lpServiceTable ) ) 
       bRetVal = HB_TRUE; 
    else 
       ulSvcError = ( ULONG ) GetLastError(); 
  
    hb_retl( bRetVal ); 
 } 
  
 HB_FUNC( LETO_SERVICEINSTALL ) 
 { 
    HB_BOOL bRetVal = HB_FALSE; 
    TCHAR szPath[ MAX_PATH ]; 
    SC_HANDLE schSrv, schSCM; 
  
    DWORD sz;                          // BAA 
    SERVICE_DESCRIPTION sd;            // BAA 
     
   
    sz = leto_GetNameService( szPath );   // BAA 
  
    if( sz ) 
    { 
  
       schSCM = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS ); 
  
       if( schSCM ) 
       { 
          schSrv = CreateService( schSCM, 
                                  ServiceName, 
                                  ServiceDisplayName, 
                                  SERVICE_ALL_ACCESS, 
                                  SERVICE_WIN32_OWN_PROCESS, 
                                  SERVICE_AUTO_START,        //SERVICE_DEMAND_START, 
                                  SERVICE_ERROR_NORMAL, 
                                  szPath, 
                                  NULL, NULL, NULL, NULL, NULL ); 
  
          if( schSrv ) 
          { 
            
             // BAA -  Set Description 
             sd.lpDescription = ServiceDescription; 
  
             ChangeServiceConfig2( schSrv, SERVICE_CONFIG_DESCRIPTION, &sd); 
             // BAA  
  
             CloseServiceHandle( schSrv ); 
             bRetVal = HB_TRUE; 
          } 
          else 
          { 
             ulSvcError = ( ULONG ) GetLastError(); 
          } 
  
          CloseServiceHandle( schSCM ); 
       } 
       else 
          ulSvcError = ( ULONG ) GetLastError(); 
    } 
  
    hb_retl( bRetVal ); 
 } 
  
 HB_FUNC( LETO_SERVICEDELETE ) 
 { 
    TCHAR szPath[ MAX_PATH ]; 
    HB_BOOL bRetVal = HB_FALSE; 
  
    SC_HANDLE schSCM = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS ); 
  
    if( schSCM ) 
    { 
       SC_HANDLE schService; 
       SERVICE_STATUS_PROCESS ssp; 
       DWORD dwStartTime, dwTimeout, dwWaitTime; 
       DWORD dwBytesNeeded; 
  
       leto_GetNameService( szPath );    // BAA - define  ServiceName, ... 
  
       // check and stop 
       schService = OpenService( schSCM, ServiceName, SERVICE_STOP | SERVICE_QUERY_STATUS ); 
       if( schService ) 
       { 
          dwStartTime = GetTickCount(); 
  
          dwTimeout   = 30000; // BAA moved,   30-seconds time-out   
  
          // Make sure the service is not already stopped. 
          if( QueryServiceStatusEx( schService, SC_STATUS_PROCESS_INFO, (LPBYTE) &ssp, 
                                        sizeof(SERVICE_STATUS_PROCESS), &dwBytesNeeded ) ) 
          { 
             // If a stop is pending, wait for it. 
  
             while( ssp.dwCurrentState == SERVICE_STOP_PENDING ) 
             { 
                dwWaitTime = ssp.dwWaitHint / 10; 
                if( dwWaitTime < 1000 ) 
                   dwWaitTime = 1000; 
                else if( dwWaitTime > 10000 ) 
                   dwWaitTime = 10000; 
  
                Sleep( dwWaitTime ); 
  
                if( !QueryServiceStatusEx( schService, SC_STATUS_PROCESS_INFO, (LPBYTE) &ssp, 
                                              sizeof(SERVICE_STATUS_PROCESS), &dwBytesNeeded ) ) 
                { 
                   break; 
                } 
  
                if( ssp.dwCurrentState == SERVICE_STOPPED ) 
                   break; 
  
                if( GetTickCount() - dwStartTime > dwTimeout ) 
                   break; 
             } 
          } 
  
          // Send a stop code to the service. 
          if( ControlService( schService, SERVICE_CONTROL_STOP, (LPSERVICE_STATUS) &ssp ) ) 
          { 
             // Wait for the service to stop. 
             while( ssp.dwCurrentState != SERVICE_STOPPED ) 
             { 
                dwWaitTime = ssp.dwWaitHint / 10; 
                if( dwWaitTime < 1000 ) 
                   dwWaitTime = 1000; 
                else if( dwWaitTime > 10000 ) 
                   dwWaitTime = 10000; 
  
                // Sleep( ssp.dwWaitHint ); 
                Sleep( dwWaitTime );           // BAA - define checked WaitTime 
  
                if( !QueryServiceStatusEx( schService, SC_STATUS_PROCESS_INFO, (LPBYTE) &ssp, 
                                           sizeof(SERVICE_STATUS_PROCESS), &dwBytesNeeded ) ) 
                { 
                   break; 
                } 
                if( ssp.dwCurrentState == SERVICE_STOPPED ) 
                   break; 
  
                if( GetTickCount() - dwStartTime > dwTimeout ) 
                   break; 
             } 
          } 
  
          CloseServiceHandle( schService ); 
       } 
  
       // delete 
       schService = OpenService( schSCM, ServiceName, DELETE ); 
       if( schService ) 
       { 
          bRetVal = ( HB_BOOL ) DeleteService( schService ); 
          CloseServiceHandle( schService ); 
          if( ! bRetVal ) 
          { 
             ulSvcError = ( ULONG ) GetLastError(); 
          } 
       } 
       else 
          ulSvcError = ( ULONG ) GetLastError(); 
  
       CloseServiceHandle( schSCM ); 
    } 
  
    hb_retl( bRetVal ); 
 } 
  
 HB_FUNC( LETOWIN_GETLASTERROR ) 
 { 
    hb_retnl( ulSvcError ); 
 } 
  
 #endif 
  
 /* 
 extern char carr1[40][40]; 
 extern USHORT uiarr1len; 
 extern char carr2[100][40]; 
 extern USHORT uiarr2len; 
  
 typedef struct 
 { 
    HANDLE hMem; 
    LPVOID lpView; 
    BOOL bNewArea; 
 } MEMAREA; 
  
 static MEMAREA s_MemArea = { 0,0,0 }; 
  
  
 HB_FUNC( LETO_MSG ) 
 { 
    LPTSTR lpMsg = HB_TCHAR_CONVTO( hb_parcx( 1 ) ); 
  
    MessageBox( GetActiveWindow(), lpMsg, TEXT( "Leto db server" ), MB_OK ); 
  
    HB_TCHAR_FREE( lpMsg ); 
 } 
  
 HB_FUNC( LETO_CREATEMEMAREA ) 
 { 
    char szId[16]; 
  
    sprintf( szId, "%s%d", "Leto_DB_", hb_parni(1) ); 
    s_MemArea.hMem = CreateFileMapping( (HANDLE)0xFFFFFFFF, NULL, PAGE_READWRITE, 0, 1024, (LPCTSTR)szId ); 
  
    if( s_MemArea.hMem ) 
    { 
       s_MemArea.bNewArea = !( GetLastError() == ERROR_ALREADY_EXISTS ); 
       s_MemArea.lpView = MapViewOfFile( s_MemArea.hMem, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0 ); 
       if( s_MemArea.bNewArea ) 
          ((char*)s_MemArea.lpView)[0] = 'L'; 
    } 
  
    hb_retni( (s_MemArea.hMem)?  s_MemArea.bNewArea : -1 ); 
 } 
  
 void leto_CloseMemArea( void ) 
 { 
    if( s_MemArea.lpView ) 
       UnmapViewOfFile( s_MemArea.lpView ); 
    if( s_MemArea.hMem ) 
       CloseHandle( s_MemArea.hMem ); 
 } 
  
 HB_FUNC( LETO_CLOSEMEMAREA ) 
 { 
    leto_CloseMemArea(); 
 } 
  
 BOOL leto_ReadMemArea( char * szBuffer, int iAddr, int iLength ) 
 { 
    if( !s_MemArea.lpView ) 
       return FALSE; 
  
    memcpy( szBuffer, ((char*)s_MemArea.lpView)+iAddr, iLength ); 
    szBuffer[iLength] = '\0'; 
    return TRUE; 
 } 
  
 BOOL leto_WriteMemArea( const char * szBuffer, int iAddr, int iLength ) 
 { 
    if( !s_MemArea.lpView ) 
       return FALSE; 
  
    memcpy( ((char*)s_MemArea.lpView)+iAddr, szBuffer, iLength ); 
    return TRUE; 
 } 
  
 BOOL leto_ThreadCreate( unsigned int (__stdcall *ThreadFunc)(void*) ) 
 { 
    unsigned int uiThreadID; 
    if( _beginthreadex( NULL, 0, ThreadFunc, (void *) NULL, 0, &uiThreadID ) ) 
    { 
       return TRUE; 
    } 
    else 
       return FALSE; 
 } 
  
  
 BOOL leto_ThreadMutexInit( LETO_MUTEX * pMutex ) 
 { 
    InitializeCriticalSection( pMutex ); 
    return TRUE; 
 } 
  
 void leto_ThreadMutexDestroy( LETO_MUTEX * pMutex ) 
 { 
    DeleteCriticalSection( pMutex ); 
 } 
  
 BOOL leto_ThreadMutexLock( LETO_MUTEX * pMutex ) 
 { 
    EnterCriticalSection( pMutex ); 
    return TRUE; 
 } 
  
 BOOL leto_ThreadMutexUnlock( LETO_MUTEX * pMutex ) 
 { 
    LeaveCriticalSection( pMutex ); 
    return TRUE; 
 } 
  
 BOOL leto_ThreadCondInit( LETO_COND * pCond  ) 
 { 
    if( ( pCond->hEvent = CreateEvent( NULL, FALSE, FALSE, NULL ) ) == 0 ) 
       return FALSE; 
    else 
       return TRUE; 
 } 
  
 void leto_ThreadCondDestroy( LETO_COND * pCond ) 
 { 
    CloseHandle( pCond->hEvent ); 
 } 
  
 int leto_ThreadCondWait( LETO_COND * pCond, int iMilliseconds ) 
 { 
    DWORD dw; 
  
    InterlockedExchange( &(pCond->ulLocked), 1 ); 
    dw = WaitForSingleObject( pCond->hEvent, 
                  (iMilliseconds<0)? INFINITE : (DWORD)iMilliseconds ); 
    switch( dw ) 
    { 
       case WAIT_OBJECT_0: 
       { 
          InterlockedExchange( &(pCond->ulLocked), 0 ); 
          return 1; 
       } 
       case WAIT_TIMEOUT: 
          return 0; 
    } 
    return -1; 
 } 
  
 BOOL leto_ThreadCondUnlock( LETO_COND * pCond ) 
 { 
    BOOL bRes; 
  
    if( pCond->ulLocked ) 
    { 
       bRes = SetEvent( pCond->hEvent ); 
       if (!bRes) 
          InterlockedExchange( &(pCond->ulLocked), 0 ); 
       return bRes; 
    } 
    return FALSE; 
 } 
 */