예제 #1
0
void KillGLTextures()
{
    if(bHasTextures)
    {
        glDeleteBuffers(2, gltextures);
        bHasTextures = FALSE;
    }

    DestroySharedMemory();
}
예제 #2
0
void ClearD3D11Data()
{
    bHasTextures = false;
    texData = NULL;
    sharedHandle = NULL;

    SafeRelease(copyTextureGame);

    DestroySharedMemory();
}
예제 #3
0
void ClearD3D11Data()
{
    bHasTextures = false;
    for(UINT i=0; i<2; i++)
    {
        SafeRelease(d3d11Textures[i]);
    }

    DestroySharedMemory();
}
예제 #4
0
void ClearD3D101Data()
{
    bHasTextures = false;
    texData = NULL;
    sharedHandle = NULL;

    SafeRelease(copyD3D101TextureGame);

    DestroySharedMemory();
    keepAliveTime = 0;
    resetCount++;

    logOutput << CurrentTimeString() << "---------------------- Cleared D3D10.1 Capture ----------------------" << endl;
}
예제 #5
0
bool
IProtocol::DeallocShmem(Shmem& aMem)
{
  bool ok = DestroySharedMemory(aMem);
#ifdef DEBUG
  if (!ok) {
    if (mSide == ChildSide) {
      FatalError("bad Shmem");
    } else {
      NS_WARNING("bad Shmem");
    }
    return false;
  }
#endif // DEBUG
  aMem.forget(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
  return ok;
}
예제 #6
0
void ClearD3D11Data()
{
    bHasTextures = false;
    if(texData)
        texData->lastRendered = -1;
    texData = NULL;

    for(UINT i=0; i<2; i++)
    {
        SafeRelease(keyedMutexes[i]);
        SafeRelease(sharedTextures[i]);
        sharedHandles[i] = NULL;
    }

    SafeRelease(copyTextureGame);
    SafeRelease(copyTextureIntermediary);
    SafeRelease(shareDevice);

    DestroySharedMemory();
}
예제 #7
0
int CreateSharedMemory ( void ) {

  struct stat statbuf;
  char *Path = NULL;
  struct group *grp;
  struct shmid_ds shm_info;

#if !MMAP
  if ( ((Path = getenv("PKCS11_SHMEM_FILE")) == NULL ) || ( Path[0] == '\0' ) ) {
    Path = TOK_PATH;
  }
  InfoLog( "Shared memory file is %s", Path);

   // Get shared memory key token all users of the shared memory
   // need to get the same token

   if ( stat(Path, &statbuf) < 0 ) {
      ErrLog("Shared Memory Key Token creation file does not exist");
      return FALSE;
   }
   // SAB  Get the group information for the PKCS#11 group... fail if
   // it does not exist
   grp = getgrnam("pkcs11");
   if ( !grp ) {
     ErrLog("Group PKCS#11 does not exist ");
     return FALSE;  // Group does not exist... setup is wrong..
   }


   tok = ftok(Path ,'b');
   // Allocate the shared memory... Fail if the memory is already
   // allocated since the slot mgr is the owner of it.

   // Is this some attempt at exclusivity, or is that just a side effect? - SCM 9/1

   shmid = shmget( tok, sizeof( Slot_Mgr_Shr_t ),
                   IPC_CREAT | IPC_EXCL |  S_IRUSR |
	           S_IRGRP  | S_IWUSR | S_IWGRP   );

   // Explanation of options to shmget():

   /* 
    *  IPC_CREAT  Creates the data structure if it does not already exist.
    *  IPC_EXCL   Causes the shmget subroutine to be unsuccessful if the 
    *             IPC_CREAT flag is also set, and the data structure already exists.
    *  S_IRUSR    Permits the process that owns the data structure to read it.
    *  S_IWUSR    Permits the process that owns the data structure to modify it.
    *  S_IRGRP    Permits the group associated with the data structure to read it.
    *  S_IWGRP    Permits the group associated with the data structure to modify it.
    *
    *
    *  WE DON"T WANT OTHERS
    *  S_IROTH    Permits others to read the data structure.
    *  S_IWOTH    Permits others to modify the data structure.
    */


   if ( shmid < 0 ) {
      ErrLog("Shared memory creation failed (0x%X)\n", errno);
      ErrLog("Reclaiming 0x%X\n", tok);
      shmid = shmget( tok, sizeof( Slot_Mgr_Shr_t ), 0 );
      DestroySharedMemory();
      shmid = shmget( tok, sizeof( Slot_Mgr_Shr_t ),
                      IPC_CREAT | IPC_EXCL |  S_IRUSR |
	              S_IRGRP  | S_IWUSR | S_IWGRP   );
      if ( shmid < 0 ) {
          ErrLog("Shared memory reclamation failed (0x%X)\n", errno);
          ErrLog("perform ipcrm -M 0x%X\n", tok);
          return FALSE;
      }
   }

   // SAB Set the group ownership of the shared mem segment..
   // we already have the group structure..
   
   if ( shmctl(shmid, IPC_STAT,&shm_info) == 0 ) {

        shm_info.shm_perm.gid = grp->gr_gid;

        if (shmctl(shmid,IPC_SET,&shm_info) == -1) {
             ErrLog("Failed to set group ownership for shm \n");
             shmctl(shmid, IPC_RMID,NULL);        
        }

   } else {
        ErrLog("Can't get status of shared memory %d\n",errno);
        // we know it was created... we need to destroy it...
        shmctl(shmid, IPC_RMID,NULL);        

   }
   


   return TRUE;
#else   
{
#warning "EXPERIMENTAL"
   int fd;
   int i;
   char *buffer;
   
   grp = getgrnam("pkcs11");
   if ( !grp ) {
     ErrLog("Group \"pkcs11\" does not exist! Please run %s/pkcs11_startup.",
		     SBIN_PATH);
     return FALSE;  // Group does not exist... setup is wrong..
   }

   fd = open(MAPFILENAME,O_RDWR,MODE);
   if (fd < 0 ) {
     // File does not exist... this is cool, we creat it here
     fd = open(MAPFILENAME,O_RDWR|O_CREAT,MODE); // Create the file
     if (fd < 0 ){ // We are really hosed here, since we should be able
       // to create the file now
       ErrLog("%s: open(%s): %s", __FUNCTION__, MAPFILENAME, strerror(errno));
       return FALSE;
     } else {
       if (fchmod(fd, MODE) == -1) {
	 ErrLog("%s: fchmod(%s): %s", __FUNCTION__, MAPFILENAME, strerror(errno));
	 close(fd);
	 return FALSE;
       }
       if (fchown(fd, 0, grp->gr_gid) == -1) {
	 ErrLog("%s: fchown(%s, root, pkcs11): %s", __FUNCTION__, MAPFILENAME,
		strerror(errno));
	 close(fd);
	 return FALSE;
       }
       // Create a buffer and make the file the right length
       i = sizeof(Slot_Mgr_Shr_t);
       buffer = malloc(sizeof(Slot_Mgr_Shr_t));
       memset(buffer,'\0',i);
       write(fd,buffer,i);
       free(buffer);
       close(fd);
     }
   } else {
     ErrLog("%s: [%s] exists; you may already have a pkcsslot daemon running. If this "
	    "is not the case, then the prior daemon was not shut down cleanly. "
	    "Please delete this file and try again\n", __FUNCTION__, MAPFILENAME);
     close(fd); 
     return FALSE;
   }
   return TRUE;
}

#endif

}
예제 #8
0
int main ( int argc, char *argv[], char *envp[]) {
   int ret;

   /**********************************/
   /* Read in command-line arguments */
   /**********************************/

   /* FIXME: Argument for daemonizing or not */
   /* FIXME: Argument for debug level */
   /* FIXME: Arguments affecting the log files, whether to use syslog, etc. (Read conf file?) */


   /* Report our debug level */
   if ( GetDebugLevel() > DEBUG_NONE) {

     DbgLog(GetDebugLevel(), "Starting with debugging messages logged at level %d (%d = No messages; %d = few; %d = more, etc.)", 
	    GetDebugLevel(), DEBUG_NONE, DEBUG_LEVEL0, DEBUG_LEVEL1);

   }


   /* Save our startup directory */
   SaveStartupDirectory( argv[0]  );

   ret = load_and_parse(OCK_CONFIG);
   if (ret != 0) {
      ErrLog("Failed to read config file.\n");
      return 1;
   } else
      DbgLog (DL0, "Parse config file succeeded.\n");

   /* Allocate and Attach the shared memory region */
   if ( ! CreateSharedMemory() ) {
     /* CreateSharedMemory() does it's own error logging */
     return 1;
   }

   DbgLog(DL0,"SHMID %d  token %#X \n", shmid, tok);

   /* Now that we've created the shared memory segment, we attach to it */
   if ( ! AttachToSharedMemory() ) {
     /* AttachToSharedMemory() does it's own error logging */
     DestroySharedMemory();
     return 2;
   }

   /* Initialize the global shared memory mutex (and the attribute used to create the per-process mutexes */
   if ( ! InitializeMutexes() ) {
     DetachFromSharedMemory();
     DestroySharedMemory();
     return 3;
   }

   /* Get the global shared memory mutex */

   XProcLock();

   /* Populate the Shared Memory Region */
   if ( ! InitSharedMemory(shmp) ) {

      XProcUnLock();

     DetachFromSharedMemory();
     DestroySharedMemory();
     return 4;
   }
   
   /* Release the global shared memory mutex */
   XProcUnLock();

   if ((socketfd = CreateListenerSocket()) < 0) {
      DestroyMutexes();
      DetachFromSharedMemory();
      DestroySharedMemory();
      return 5;
   }

   if (!InitSocketData(&socketData)) {
      DetachSocketListener(socketfd);
      DestroyMutexes();
      DetachFromSharedMemory();
      DestroySharedMemory();
      return 6;
   }

   /*
    *  Become a Daemon, if called for
    */
   if ( Daemon ) {
        pid_t  pid;
        if ( (pid = fork()) < 0 ){
          DetachSocketListener(socketfd);
          DestroyMutexes();
          DetachFromSharedMemory();
          DestroySharedMemory();
          return 7;
        } else {
           if ( pid != 0) {
              exit(0); // Terminate the parent
           } else {

              setsid(); // Session leader
#ifndef DEV
              fclose(stderr);
              fclose(stdout);
              fclose(stdin);
#endif

           }
        }


   } else {

#ifdef DEV
     // Log only on development builds
     LogLog("Not becoming a daemon...\n");
#endif

   }

   
   /*****************************************
    * 
    * Register Signal Handlers
    * Daemon probably should ignore ALL signals possible, since termination
    * while active is a bad thing...  however one could check for 
    * any processes active in the shared memory, and destroy the shm if
    * the process wishes to terminate.
    * 
    *****************************************/

   /*   
    *   We have to set up the signal handlers after we daemonize because
    *   the daemonization process redefines our handler for (at least) SIGTERM
    */

   if ( ! SetupSignalHandlers() ) {
     DetachSocketListener(socketfd);
     DestroyMutexes();
     DetachFromSharedMemory();
     DestroySharedMemory();
     return 8;
   }




   /*  ultimatly we will create a couple of threads which monitor the slot db
       and handle the insertion and removal of tokens from the slot.
    */

   /* For Testing the Garbage collection routines */
   /*
      shmp->proc_table[3].inuse = TRUE;
      shmp->proc_table[3].proc_id = 24328;
      */

#if !defined(NOGARBAGE)
printf("Start garbage \n");
   /* start garbage collection thread */
   if ( ! StartGCThread(shmp) ) {
     DetachSocketListener(socketfd);
     DestroyMutexes();
     DetachFromSharedMemory();
     DestroySharedMemory();
     return 9;
   }
#endif

     // We've fully become a daemon.  Now create the PID file
     {
        FILE *pidfile;

        pidfile = fopen(PID_FILE_PATH,"w");
        if (pidfile) {
           fprintf(pidfile,"%d",getpid());
	   fclose(pidfile);
        }
     }

   while (1) {
#if !(THREADED) && !(NOGARBAGE)
     CheckForGarbage(shmp);
#endif

     SocketConnectionHandler(socketfd, 10);

   }


   /*************************************************************
    * 
    *  Here we need to actualy go through the processes and verify that thye
    *  still exist.  If not, then they terminated with out properly calling
    *  C_Finalize and therefore need to be removed from the system.
    *  Look for a system routine to determine if the shared memory is held by 
    *  the process to further verify that the proper processes are in the 
    *  table.
    * 
    *************************************************************/

} /* end main */
예제 #9
0
void CleanUpDDraw()
{
    logOutput << CurrentTimeString() << "Cleaning up" << endl;
    if (copyData)
        copyData->lastRendered = -1;

    if (hCopyThread)
    {
        bKillThread = true;
        SetEvent(hCopyEvent);
        if (WaitForSingleObject(hCopyThread, 500) != WAIT_OBJECT_0)
            TerminateThread(hCopyThread, -1);

        CloseHandle(hCopyThread);
        CloseHandle(hCopyEvent);

        hCopyThread = NULL;
        hCopyEvent = NULL;
    }

    ddrawSurfaceRelease.Unhook();
    for (int i = 0; i < NUM_BUFFERS; i++)
    {
        if (ddCaptures[i])
        {
            ddCaptures[i]->Release();
            ddCaptures[i] = NULL;
        }
    }
    ddrawSurfaceRelease.Rehook();

    DestroySharedMemory();

    bHasTextures = false;
    curCapture = 0;
    curCPUTexture = 0;
    keepAliveTime = 0;
    resetCount++;
    copyWait = 0;
    lastTime = 0;
    g_frontSurface = NULL;
    g_bUseFlipMethod = false;
    bTargetAcquired = false;
    g_dwSize = 0;
    g_bUse32bitCapture = false;
    g_bConvert16to32 = false;
    g_bUsePalette = false;
    g_dwCaptureSize = 0;

    if (g_ddInterface)
    {
        g_ddInterface->Release();
        g_ddInterface = NULL;
    }

    g_CurrentPalette.Free();

    if (g_surfaceDesc)
        delete g_surfaceDesc;
    g_surfaceDesc = NULL;

    if (ddUnlockFctMutex)
    {
        CloseHandle(ddUnlockFctMutex);
        ddUnlockFctMutex = 0;
    }

    //UnhookAll();

    logOutput << CurrentTimeString() << "---------------------- Cleared DirectDraw Capture ----------------------" << endl;
}
예제 #10
0
void MhProtoClient::ClearResources(void) {
    if (sem_ != NULL) delete sem_;
    DestroySharedMemory();
}
예제 #11
0
MhProtoClient::~MhProtoClient(void) {
    DEBUG("MhProtoClient::Destructor\n");
    if (sem_ != NULL) delete sem_;
    DestroySharedMemory();
}
예제 #12
0
void ClearGLData()
{
    if(copyData)
        copyData->lastRendered = -1;

    if(hCopyThread)
    {
        bKillThread = true;
        SetEvent(hCopyEvent);
        if(WaitForSingleObject(hCopyThread, 500) != WAIT_OBJECT_0)
            TerminateThread(hCopyThread, -1);

        CloseHandle(hCopyThread);
        CloseHandle(hCopyEvent);

        hCopyThread = NULL;
        hCopyEvent = NULL;
    }

    for(int i=0; i<NUM_BUFFERS; i++)
    {
        if(glLockedTextures[i])
        {
            OSEnterMutex(glDataMutexes[i]);

            glBindBuffer(GL_PIXEL_PACK_BUFFER, gltextures[i]);
            glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
            glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);

            glLockedTextures[i] = false;

            OSLeaveMutex(glDataMutexes[i]);
        }
    }

    if(bHasTextures)
    {
        glDeleteBuffers(NUM_BUFFERS, gltextures);
        bHasTextures = false;

        ZeroMemory(gltextures, sizeof(gltextures));
    }

    for(int i=0; i<NUM_BUFFERS; i++)
    {
        if(glDataMutexes[i])
        {
            OSCloseMutex(glDataMutexes[i]);
            glDataMutexes[i] = NULL;
        }
    }

    DestroySharedMemory();
    copyData = NULL;
    copyWait = 0;
    lastTime = 0;
    curCapture = 0;
    curCPUTexture = 0;
    keepAliveTime = 0;
    resetCount++;
    pCopyData = NULL;

    logOutput << CurrentTimeString() << "---------------------- Cleared OpenGL Capture ----------------------" << endl;
}