Пример #1
0
PQTOPLEVEL32 prc32GetInfo2(ULONG fl,        // in: QS32_* flags
                           APIRET *parc)    // out: error, ptr can be NULL
{
    APIRET          arc;
    PQTOPLEVEL32    pReturn = NULL;

    #define BUFSIZE (1024 * 1024) // 1 meg

    if (!(arc = DosAllocMem((PVOID*)&pReturn,
                            BUFSIZE,
                            PAG_READ | PAG_WRITE | PAG_COMMIT | OBJ_TILE)))
    {
        if (arc = DosQuerySysState(fl,
                                   fl,      // this was missing V0.9.10 (2001-04-08) [umoeller]
                                   0, 0,
                                   (PCHAR)pReturn,
                                   BUFSIZE))
        {
            DosFreeMem(pReturn);
            pReturn = NULL;
        }
    }

    if (parc)
        *parc = arc;

    return pReturn;
}
Пример #2
0
APIRET QuerySysInfo(void)
{
    APIRET RC;
    if(!pqData)
        pqData = (PQTOPLEVEL) new char[PQ_BUFSIZE];
    memset(pqData, 0, PQ_BUFSIZE);
    RC = DosQuerySysState(0x1F, 0, 0, 0, pqData, PQ_BUFSIZE);
    return RC;
}
Пример #3
0
MRESULT khs_umIsExceptWindow( HWND hwnd, MPARAM mp1, MPARAM mp2 )
{
    PKHSCD      pkhscd = WinQueryWindowPtr( hwnd, 0 );
    HWND        hwndTarget = HWNDFROMMP( mp1 );
    PID         pid;
    PCHAR       modulePath;
    PCHAR       moduleName;
    ULONG       maxPathLen;
    APIRET      rc;
    BOOL        result;

    WinQueryWindowProcess( hwndTarget, &pid, NULL );

#ifdef DEBUG
    fprintf( pkhscd->fp, "PID = %x\n", pid );
#endif

    memset( pkhscd->pQTopLevel, 0, DOSQSS_BUFSIZE );

    rc = DosQuerySysState( 0x01, 0, pid, 1, pkhscd->pQTopLevel, DOSQSS_BUFSIZE );
    if( rc != 0 )
        return FALSE;

    DosQuerySysInfo( QSV_MAX_PATH_LENGTH, QSV_MAX_PATH_LENGTH, &maxPathLen, sizeof( ULONG ));

    modulePath = malloc( maxPathLen );
    DosQueryModuleName( pkhscd->pQTopLevel->procdata->hndmod, maxPathLen, modulePath );

#ifdef DEBUG
    fprintf( pkhscd->fp, "Module path = %s\n", modulePath );
#endif

    moduleName = strrchr( modulePath, '\\' );
    if( moduleName == NULL )
        moduleName = modulePath;
    else
        moduleName++;

#ifdef DEBUG
    fprintf( pkhscd->fp, "Module name = %s\n", moduleName );
#endif

    result = exceptFindName( pkhscd->exceptListBuf, moduleName );

    free( modulePath );

#ifdef DEBUG
    fprintf( pkhscd->fp, "exceptFindName() = %ld\n", result );

    fflush( pkhscd->fp );
#endif

    return MRFROMLONG( result );
}
Пример #4
0
ULONG APIENTRY getSGID( VOID )
{
    PQTOPLEVEL  pQTopLevel = ( PQTOPLEVEL )m_achSysState;
    PPIB        ppib;

    if( m_ulSGID != ( ULONG )-1 )
        return m_ulSGID;

    DosGetInfoBlocks( NULL, &ppib );

    DosQuerySysState( 0x01, 0, ppib->pib_ulpid, 1, pQTopLevel, BUF_SIZE );

    m_ulSGID = pQTopLevel->procdata->sessid;

    return m_ulSGID;
}
Пример #5
0
void
FillMenu( HWND hwndMenu )
{
  char      szPidPath[1024];
  char      szBuffer[1024];
  char*     pBuf;
  QSPTRREC* pRecHead;
  QSPREC*   pApp;
  int       numItems, iCounter;
  PVOID     pBuffer;
  PSWBLOCK  pSB;
  TASKDATA* data;
  SHORT     id = ID_ITEM_FIRST;

  // Delete all current items
  numItems = LONGFROMMR( WinSendMsg( hwndMenu, MM_QUERYITEMCOUNT, 0, 0 ));

  while( numItems-- )
  {
    MENUITEM mi;
    SHORT    id = LONGFROMMR( WinSendMsg( hwndMenu,
                              MM_ITEMIDFROMPOSITION, MPFROMSHORT(0), 0 ));

    if( WinSendMsg( hwndMenu, MM_QUERYITEM,
                    MPFROM2SHORT( id, FALSE ), MPFROMP( &mi )))
    {
      if( mi.hItem )
      {
        data = (TASKDATA*)mi.hItem;

        free( data->szTitle );
        free( data );
      }
    }

    WinSendMsg( hwndMenu, MM_DELETEITEM,
                MPFROM2SHORT( id, FALSE ), 0 );
  }

  if( bType )
  {
    // Ctrl is pressed, get the processes in the system.
    pBuf = (char*)malloc( 0x8000 );

    // Get processes
    DosQuerySysState( QS_PROCESS, 0, 0, 0, (char*)pBuf, 0x8000 );

    // Point to first process
    pRecHead = (QSPTRREC*)pBuf;
    pApp = pRecHead->pProcRec;

    // While its a process record
    while( pApp->RecType == 1 )
    {
      // Get module name for process
      memset( szPidPath, 0, _MAX_PATH );
      DosQueryModuleName( pApp->hMte, 512, szPidPath );

      if( strlen( szPidPath ) == 0 )
      {
        // If no hit is the kernel
        if( pApp->type == 1 ) {
          sprintf( szPidPath, "VDM (%d)", pApp->pid );
        } else {
          strcpy ( szPidPath, "*SYSINIT" );
        }
      }
      else
      {
        // Else trim the path
        strcpy ( szBuffer, FileGetFileExt( szPidPath ));
        sprintf( szPidPath, "%s (%d)", szBuffer, pApp->pid );
      }

      // add to menu
      data = (TASKDATA*)malloc( sizeof( TASKDATA ));
      data->szTitle = strdup( szPidPath );
      data->hWindow = NULLHANDLE;
      data->pid = pApp->pid;

      switch( pApp->type ) {
        case  0: data->hIcon = ico_os2fs;  break;
        case  1: data->hIcon = ico_dos;    break;
        case  2: data->hIcon = ico_os2vio; break;
        case  3: data->hIcon = ico_pm;     break;
        case  4: data->hIcon = ico_detach; break;
        default: data->hIcon = NULLHANDLE; break;
      }

      winhInsertMenuItem( hwndMenu, MIT_END,
                          id++, szPidPath, MIS_OWNERDRAW, 0, data );
      // get next record
      pApp=(QSPREC *)((pApp->pThrdRec) + pApp->cTCB);
    }

    free(pBuf);
  }
  else
  {
    // Get number of items in switchlist
    numItems = WinQuerySwitchList( WinQueryAnchorBlock( hwndMenu ), NULL, 0 );

    // Get all items into buffer
    pBuffer = malloc(( numItems * sizeof(SWENTRY)) + sizeof(HSWITCH));

    WinQuerySwitchList( WinQueryAnchorBlock(hwndMenu),
                        (SWBLOCK*)pBuffer,
                        (numItems * sizeof(SWENTRY)) + sizeof(HSWITCH));

    pSB = (PSWBLOCK)(pBuffer);
    for( iCounter = 0; iCounter < numItems; iCounter++ )
    {
      // Should be JUMPABLE and VISIBLE to show in list
      if( pSB->aswentry[iCounter].swctl.uchVisibility == SWL_VISIBLE )
      {

        // Put in menu
        data = (TASKDATA*)malloc( sizeof( TASKDATA ));
        data->szTitle = strdup( pSB->aswentry[iCounter].swctl.szSwtitle );
        data->hWindow = pSB->aswentry[iCounter].swctl.hwnd;
        data->pid = pSB->aswentry[iCounter].swctl.idProcess;
        CleanString( data->szTitle );

        if( pSB->aswentry[iCounter].swctl.hwndIcon != NULLHANDLE ) {
          data->hIcon = pSB->aswentry[iCounter].swctl.hwndIcon;
        } else {
          data->hIcon = (HPOINTER)WinSendMsg( data->hWindow, WM_QUERYICON, 0, 0 );
        }

        winhInsertMenuItem( hwndMenu, MIT_END, id++,
                            pSB->aswentry[iCounter].swctl.szSwtitle,
                            MIS_OWNERDRAW, 0, data );
      }
    }
    free(pBuffer);
  }
}
Пример #6
0
int RAND_poll (void)
{
    char failed_module[20];

    QWORD qwTime;

    ULONG SysVars[QSV_FOREGROUND_PROCESS];

    if (hDoscalls == 0)
    {
        ULONG rc = DosLoadModule (failed_module, sizeof (failed_module), "DOSCALLS", &hDoscalls);

#ifndef __KLIBC__
        if (rc == 0)
        {
            rc = DosQueryProcAddr (hDoscalls, 976, NULL, (PFN *) & DosPerfSysCall);

            if (rc)
                DosPerfSysCall = NULL;

            rc = DosQueryProcAddr (hDoscalls, 368, NULL, (PFN *) & DosQuerySysState);

            if (rc)
                DosQuerySysState = NULL;
        }
#endif
    }

    /* Sample the hi-res timer, runs at around 1.1 MHz */
    DosTmrQueryTime (&qwTime);
    RAND_add (&qwTime, sizeof (qwTime), 2);

    /* Sample a bunch of system variables, includes various process & memory statistics */
    DosQuerySysInfo (1, QSV_FOREGROUND_PROCESS, SysVars, sizeof (SysVars));
    RAND_add (SysVars, sizeof (SysVars), 4);

    /* If available, sample CPU registers that count at CPU MHz
     * Only fairly new CPUs (PPro & K6 onwards) & OS/2 versions support this
     */
    if (DosPerfSysCall)
    {
        CPUUTIL util;

        if (DosPerfSysCall (CMD_KI_RDCNT, (ULONG) & util, 0, 0) == 0)
        {
            RAND_add (&util, sizeof (util), 10);
        }
        else
        {
#ifndef __KLIBC__
            DosPerfSysCall = NULL;
#endif
        }
    }

    /* DosQuerySysState() gives us a huge quantity of process, thread, memory & handle stats */
    if (DosQuerySysState)
    {
        char *buffer = OPENSSL_malloc (256 * 1024);

        if (DosQuerySysState (0x1F, 0, 0, 0, buffer, 256 * 1024) == 0)
        {
            /* First 4 bytes in buffer is a pointer to the thread count
             * there should be at least 1 byte of entropy per thread
             */
            RAND_add (buffer, 256 * 1024, **(ULONG **) buffer);
        }

        OPENSSL_free (buffer);
        return 1;
    }

    return 0;
}
Пример #7
0
double hb_secondsCPU( int n )
{
   double d = 0.0;

#if defined( HB_OS_WIN ) && ! defined( HB_OS_WIN_CE ) && ! defined( HB_OS_UNIX )
   FILETIME Create, Exit, Kernel, User;
#endif

#if defined( HB_OS_OS2 )
   static ULONG s_timer_interval = 0;

   QSGREC ** pBuf;
#endif

   if( ( n < 1 || n > 3 ) && ( n < 11 || n > 13 ) )
      n = 3;

#if defined( HB_OS_UNIX ) && ! defined( HB_OS_VXWORKS )
   {
      struct tms tm;

      times( &tm );

      if( n > 10 )
      {
         n -= 10;
         if( n & 1 )
            d += tm.tms_cutime;
         if( n & 2 )
            d += tm.tms_cstime;
      }
      if( n & 1 )
         d += tm.tms_utime;
      if( n & 2 )
         d += tm.tms_stime;

      /* In POSIX-1996 the CLK_TCK symbol is mentioned as obsolescent */
      #if 0
      d /= CLK_TCK;
      #endif
      d /= ( double ) sysconf( _SC_CLK_TCK );
   }
#else
   if( n > 10 )
      n -= 10;
#if defined( HB_OS_WIN ) && ! defined( HB_OS_WIN_CE )
   if( hb_iswinnt() &&
       GetProcessTimes( GetCurrentProcess(), &Create, &Exit, &Kernel, &User ) )
   {
      if( n & 1 )
      {
         d += ( double ) ( ( ( HB_MAXINT ) User.dwHighDateTime << 32 ) +
                             ( HB_MAXINT ) User.dwLowDateTime );
      }
      if( n & 2 )
      {
         d += ( double ) ( ( ( HB_MAXINT ) Kernel.dwHighDateTime << 32 ) +
                             ( HB_MAXINT ) Kernel.dwLowDateTime );
      }
      d /= 10000000.0;
   }
   else
#elif defined( HB_OS_OS2 )

   if( s_timer_interval == 0 )
      DosQuerySysInfo( QSV_TIMER_INTERVAL, QSV_TIMER_INTERVAL, ( PVOID ) &s_timer_interval, sizeof( ULONG ) );

   pBuf = ( QSGREC ** ) hb_xalloc( BUFSIZE );

   if( pBuf )
   {
#if defined( __GNUC__ )
      APIRET rc = DosQuerySysState( QS_PROCESS, 0L, _getpid(), 0L, pBuf, BUFSIZE );
#else
      APIRET rc = DosQuerySysState( QS_PROCESS, 0L, getpid(), 0L, pBuf, BUFSIZE );
#endif

      if( rc == NO_ERROR )
      {
         QSGREC * pGrec = *pBuf;
         QSPREC * pPrec = ( QSPREC * ) ( ( ULONG ) pGrec + sizeof( QSGREC ) );
         QSTREC * pTrec = pPrec->pThrdRec;

         int i;

         for( i = 0; i < pPrec->cTCB; i++, pTrec++ )
         {
            if( n & 1 )
               d += pTrec->usertime;

            if( n & 2 )
               d += pTrec->systime;
         }

         d = d * 10.0 / s_timer_interval;
      }

      hb_xfree( pBuf );
   }
   else

#endif
   {
      /* TODO: this code is only for DOS and other platforms which cannot
               calculate process time */

      if( n & 1 )
         d = hb_dateSeconds();
   }
#endif
   return d;
}
Пример #8
0
VOID update_thread( PVOID cntr )
{
	APIRET			rc;
	HAB				hab;
	HMQ             hmq;
	
	PVOID			pvFlipRaw,
					pvFlopRaw;

	QPROCESSARRAY   apqFlipSorted,
					apqFlopSorted;

	APPRECORDARRAY	removeList;
	QPROCESSARRAY  	procInsertList;
	QTHREADARRAY   	threadInsertList;
	QTHREADARRAY   	updateList;

	
	hab = WinInitialize( 0 );
	hmq = WinCreateMsgQueue( hab, 0 );

	rc = DosAllocMem( &pvFlipRaw, MEMPOOL, PAG_COMMIT | PAG_READ | PAG_WRITE );
	rc = DosAllocMem( &pvFlopRaw, MEMPOOL, PAG_COMMIT | PAG_READ | PAG_WRITE );
	
	rc = DosAllocMem( ( PPVOID ) &apqFlipSorted.pData,
					  sizeof( PQPROCESS ) * MAX_PROCESSES,
					  PAG_COMMIT | PAG_READ | PAG_WRITE );
	apqFlipSorted.ulSize = 0;					

	rc = DosAllocMem( ( PPVOID ) &apqFlopSorted.pData,
					  sizeof( PQPROCESS ) * MAX_PROCESSES,
					  PAG_COMMIT | PAG_READ | PAG_WRITE );
	apqFlopSorted.ulSize = 0;
		
	rc = DosAllocMem( ( PPVOID ) &removeList.pData,
					  sizeof( PAPPRECORD ) * ( MAX_PROCESSES + MAX_THREADS ),
					  PAG_COMMIT | PAG_READ | PAG_WRITE );
	removeList.ulSize = 0;
	
	rc = DosAllocMem( ( PPVOID ) &procInsertList.pData,
					  sizeof( PQPROCESS ) * MAX_PROCESSES,
					  PAG_COMMIT | PAG_READ | PAG_WRITE );
	procInsertList.ulSize = 0;
					
	rc = DosAllocMem( ( PPVOID ) &threadInsertList.pData,
					  sizeof( PQTHREAD ) * MAX_THREADS,
					  PAG_COMMIT | PAG_READ | PAG_WRITE );
	threadInsertList.ulSize = 0;

	rc = DosAllocMem( ( PPVOID ) &updateList.pData,
					  sizeof( PQTHREAD ) * MAX_THREADS,
					  PAG_COMMIT | PAG_READ | PAG_WRITE );
	updateList.ulSize = 0;

	DosCreateMutexSem( NULL,
					   &hmuxUpdate,
					   0L,
					   FALSE );

	/*
	 *  to save time, the update is done in the flip-flop way - this saves
	 *  the cost of reallocating and commiting memory
	 *
	 **/
	
    while( TRUE )
    {
    	memset( pvFlipRaw, 0, MEMPOOL );
		rc = DosQuerySysState( 0x01, 0L, 0L, 0L, ( PCHAR ) pvFlipRaw, MEMPOOL );
		sort_raw( ( PQTOPLEVEL ) pvFlipRaw, &apqFlipSorted );

		DosRequestMutexSem( hmuxUpdate, SEM_INDEFINITE_WAIT );		
		build_update_lists( &apqFlipSorted, &apqFlopSorted,
							&removeList,
							&procInsertList,
							&threadInsertList,
							&updateList );
		
		update_container( ( HWND ) cntr,
		                  &removeList,
						  &procInsertList,
						  &threadInsertList,
						  &updateList );		
		DosReleaseMutexSem( hmuxUpdate );						
							
		DosSleep( 5 * 1000 );

    	memset( pvFlopRaw, 0, MEMPOOL );
		rc = DosQuerySysState( 0x01, 0L, 0L, 0L, ( PCHAR ) pvFlopRaw, MEMPOOL );
		sort_raw( ( PQTOPLEVEL ) pvFlopRaw, &apqFlopSorted );

		DosRequestMutexSem( hmuxUpdate, SEM_INDEFINITE_WAIT );		
		build_update_lists( &apqFlopSorted, &apqFlipSorted,
							&removeList,
							&procInsertList,
							&threadInsertList,
							&updateList );
							
		update_container( ( HWND ) cntr,
						  &removeList,
						  &procInsertList,
						  &threadInsertList,
						  &updateList );
		DosReleaseMutexSem( hmuxUpdate );
									
		DosSleep( 5 * 1000 );
    };
};
Пример #9
0
void linuxContinue (
	char	*error_message,
	int	thread_num,		/* Specific worker to launch or */
					/* special value ALL_WORKERS */
	int	wait_flag)
{
#ifdef __linux__
#define PROCNAME	"/proc/%d/exe"
#endif
#ifdef __FreeBSD__
#define PROCNAME	"/proc/%d/file"
#endif
	pid_t	my_pid, running_pid;
	char	filename[30];
	int	fd;
	struct stat filedata;
	ino_t	inode1, inode2;

/* Compare this process' ID and the pid from the INI file */

	my_pid = getpid ();
	openIniFile (LOCALINI_FILE, 1);
	running_pid = IniGetInt (LOCALINI_FILE, "Pid", 0);
	if (running_pid == 0 || my_pid == running_pid) goto ok;

#if defined (__APPLE__) || defined (__HAIKU__)
	goto ok;
#elif defined (__OS2__)

        {
            USHORT handle1 = 0, handle2 = 0;
            unsigned char buf[0x2000];
            if( !DosQuerySysState(0x01, 0, 0, 0, (PCHAR)buf, 0x2000) ) {
                PQPROCESS p = ((PQTOPLEVEL)buf)->procdata;
                while(p && p->rectype == 1) {
                    if( p->pid == running_pid ) handle1 = p->hndmod;
                    if( p->pid == my_pid ) handle2 = p->hndmod;
                    p = (PQPROCESS)(p->threads + p->threadcnt);
                }
                if( handle1 != handle2 ) goto ok;
            }
        }

#else

/* See if the two pids are running the same executable */

	sprintf (filename, PROCNAME, my_pid);
	fd = _open (filename, _O_RDONLY);
	if (fd < 0) goto ok;
	fstat (fd, &filedata);
	inode1 = filedata.st_ino;
	_close (fd);
	sprintf (filename, PROCNAME, running_pid);
	fd = _open (filename, _O_RDONLY);
	if (fd < 0) goto ok;
	fstat (fd, &filedata);
	inode2 = filedata.st_ino;
	_close (fd);
	if (inode1 != inode2) goto ok;
#endif

/* The two pids are running the same executable, raise an error and return */

	if (error_message != NULL) printf ("%s", error_message);
	return;

/* All is OK, save our pid, run, then delete our pid */

ok:	IniWriteInt (LOCALINI_FILE, "Pid", my_pid);
	LaunchWorkerThreads (thread_num, wait_flag);
	if (wait_flag) IniWriteInt (LOCALINI_FILE, "Pid", 0);
}