替换exe文件资源

int   ReplaceDLLBitmapResource(   LPCWSTR   pszDLLFile,   WORD   dwResourceID,   LPCWSTR   pszBitmapFile   )  
  {  
   
  CFile f;  
  CFileException   e;  
   
  USES_CONVERSION;  
   
  if(   !   f.Open(   W2T(pszBitmapFile),   CFile::modeRead,   &e   )   )  
  return   -1;  
   
   
  BYTE   buffer[8];  
          DWORD   dwRead;  
   
  dwRead   =   f.Read(   buffer,   2   );  
  if(   buffer[0]   !=   'B'   ||   buffer[1]   !=   'M'   )  
  {  
  f.Close();    
  return   -2;  
  }  
   
   
  LONG   biWidth;  
   
  f.Seek(   18,   CFile::begin   );  
  dwRead   =   f.Read(   buffer,   sizeof(LONG)   );    
  biWidth   =   buffer[1]*256   +   buffer[0];  
   
   
  LONG   biHeight;  
   
  f.Seek(   22,   CFile::begin   );  
  dwRead   =   f.Read(   buffer,   sizeof(LONG)   );    
  biHeight   =   buffer[1]*256   +   buffer[0];  
  //   Bitmap   height   can   be   negative   too...  
   
   
  WORD   biBitCount;  
   
  f.Seek(   28,   CFile::begin   );  
  dwRead   =   f.Read(   buffer,   sizeof(LONG)   );    
  biBitCount   =   buffer[1]*256   +   buffer[0];  
   
   
  DWORD   dwSize;  
   
  f.Seek(   2,   CFile::begin   );  
  dwRead   =   f.Read(   buffer,   sizeof(DWORD)   );    
  dwSize   =   buffer[3]*256*256*256   +   buffer[2]*256*256   +   buffer[1]*256   +   buffer[0];  
  dwSize   -=   14;  
   
   
  unsigned   char*   bitmap   =   (unsigned   char*)malloc(   dwSize   );  
  if(   !bitmap   )  
  {  
  f.Close();    
  return   -3;  
  }  
   
  f.Seek(   14,   CFile::begin   );  
  dwRead   =   f.Read(   bitmap,   dwSize   );  
  if(   dwRead   !=   dwSize   )  
  {  
  f.Close();    
  return   -4;  
  }  
       
  f.Close();    
   
     
   
   
  //   Open   DLL   file    
  HANDLE   hUpdateRes   =   BeginUpdateResource(   W2T(pszDLLFile),   FALSE   );    
  if(   hUpdateRes   ==   NULL   )  
  return   -5; //   Could   not   open   file   for   writing  
     
  //   Modify   resource   to   DLL   file    
  if(   !   UpdateResource(   hUpdateRes, //   update   resource   handle    
  RT_BITMAP, //   change   bitmap   resource    
  MAKEINTRESOURCE(dwResourceID),       //   resource   name    
  MAKELANGID(LANG_ENGLISH,   SUBLANG_ENGLISH_US),     //   neutral   language  
  bitmap,                                       //   ptr   to   resource   info    
  dwSize   )   //   size   of   resource   info.    
  )  
    return   -6; //   Could   not   add   resource  
   
     
  //   Write   changes   to   DLL   file   and   then   close   it  
  if(   !   EndUpdateResource(   hUpdateRes,   FALSE   )   )    
  return   -7; //Could   not   write   changes   to   file  
   
     
  free(   bitmap   );  
   
  return   0;  
  }

 

 

Updating   Resources  
  The   following   example   copies   a   dialog   box   resource   from   one   executable   file,   Hand.exe,   to   another,   Foot.exe,   by   following   these   steps:    
   
  Use   the   LoadLibrary   function   to   load   the   executable   file   Hand.exe.    
  Use   the   FindResource   and   LoadResource   functions   to   locate   and   load   the   dialog   box   resource.    
  Use   the   LockResource   function   to   retrieve   a   pointer   to   the   dialog   box   resource   data.    
  Use   the   BeginUpdateResource   function   to   open   an   update   handle   to   Foot.exe.    
  Use   the   UpdateResource   function   to   copy   the   dialog   box   resource   from   Hand.exe   to   Foot.exe.    
  Use   the   EndUpdateResource   function   to   complete   the   update.    
  The   following   code   implements   these   steps.    
   
  HRSRC   hResLoad;           //   handle   to   loaded   resource    
  HANDLE   hExe;                 //   handle   to   existing   .EXE   file    
  HRSRC   hRes;                   //   handle/ptr.   to   res.   info.   in   hExe    
  HANDLE   hUpdateRes;     //   update   resource   handle    
  char   *lpResLock;         //   pointer   to   resource   data    
  BOOL   result;    
  //   Load   the   .EXE   file   that   contains   the   dialog   box   you   want   to   copy.    
  hExe   =   LoadLibrary("hand.exe");    
  if   (hExe   ==   NULL)    
  {    
          ErrorHandler("Could   not   load   exe.");    
  }    
     
  //   Locate   the   dialog   box   resource   in   the   .EXE   file.    
  hRes   =   FindResource(hExe,   "AboutBox",   RT_DIALOG);    
  if   (hRes   ==   NULL)    
  {    
          ErrorHandler("Could   not   locate   dialog   box.");    
  }    
     
  //   Load   the   dialog   box   into   global   memory.    
  hResLoad   =   LoadResource(hExe,   hRes);    
  if   (hResLoad   ==   NULL)    
  {    
          ErrorHandler("Could   not   load   dialog   box.");    
  }    
     
  //   Lock   the   dialog   box   into   global   memory.    
  lpResLock   =   LockResource(hResLoad);    
  if   (lpResLock   ==   NULL)    
  {    
          ErrorHandler("Could   not   lock   dialog   box.");    
  }    
     
  //   Open   the   file   to   which   you   want   to   add   the   dialog   box   resource.    
  hUpdateRes   =   BeginUpdateResource("foot.exe",   FALSE);    
  if   (hUpdateRes   ==   NULL)    
  {    
          ErrorHandler("Could   not   open   file   for   writing.");    
  }    
     
  //   Add   the   dialog   box   resource   to   the   update   list.    
  result   =   UpdateResource(hUpdateRes,               //   update   resource   handle    
            RT_DIALOG,                                       //   change   dialog   box   resource    
            "AboutBox",                                     //   dialog   box   name    
            MAKELANGID(LANG_NEUTRAL,   SUBLANG_NEUTRAL),     //   neutral   language  
            lpResLock,                                       //   ptr   to   resource   info    
            SizeofResource(hExe,   hRes));   //   size   of   resource   info.    
  if   (result   ==   FALSE)    
  {    
          ErrorHandler("Could   not   add   resource.");    
  }    
     
  //   Write   changes   to   FOOT.EXE   and   then   close   it.    
  if   (!EndUpdateResource(hUpdateRes,   FALSE))    
  {    
          ErrorHandler("Could   not   write   changes   to   file.");    
  }    
     
  //   Clean   up.    
  if   (!FreeLibrary(hExe))    
  {    
          ErrorHandler("Could   not   free   executable.");    
  }