C / C++ / MFC

Quote from Visual Studio, Microsoft Portable Executable and Common Object File Format Specification

RVA Relative virtual address. In an image file, the address of an item after it is loaded into memory, with the base address of the image file subtracted from it. The RVA of an item almost always differs from its position within the file on disk (file pointer).
In an object file, an RVA is less meaningful because memory locations are not assigned. In this case, an RVA would be an address within a section (described later in this table), to which a relocation is later applied during linking. For simplicity, a compiler should just set the first RVA in each section to zero.

manoharbalu wrote:

Please provide me step by step methods to get the values of some of the member variables

typedef struct
{
    int updateType; // Identifies the struct member that is updated
    //int dataType;   // Optional: Data type of struct member (float, char)
    int firstNdx;   // First index for array data types
    int lastNdx;    // Optional: Last index (when multiple elements must be updated)
    int dataLen;    // Optional: Size of following data ((lastNdx - firstNdx) + 1)
                    // Multiply with size of data type for byte count 
    char data[1];   // Payload placeholder
} MyUpdateProtocol;

enum MyDataMembers
{
    IVKK,
    FIL,
    FDDD,
    FCDCP,
    // ...
};

int firstNdx = 0;
int lastNdx = 10;
int dataSize = ((lastNdx - firstNdx) + 1) * sizeof(float);
// Allocate buffer for protocol header and payload.
// Using a buffer on the stack here would be faster but
//  requires the size to be known during compilation time.
//char buf[sizeof(MyUpdateProtocol) - 1 + sizeof(float) * MAX_ELEMS_TO_BE_SEND];
char *buf = new char[dataSize + sizeof(MyUpdateProtocol) - 1];
// Cast buf to a protocol type pointer.
MyUpdateProtocol *pProto = (MyUpdateProtocol *)buf;
// Initialise the protocol header fields.
pProto->updateType = IVKK;
//pProto->dataType = MUP_FLOAT;
pProto->firstNdx = firstNdx;
pProto->lastNdx = lastNdx;
pProto->dataLen = dataSize;
// Copy the payload (pModDB is a pointer to the shared data).
memcpy(pProto->data, &pModDB->IVKK[firstNdx], dataSize);
// Send it.
// Use the real size here (subtract one byte for the data[1] member).
sendData(buf, dataSize + sizeof(MyUpdateProtocol) - 1);
delete [] buf;

// Assuming received data has been copied to char *buf
MyUpdateProtocol *pProto = (MyUpdateProtocol *)buf;
void *dest = NULL;
switch (pProto->updateType)
{
    case IVKK : dest = &pModDb->IVKK[pProto->firstNdx]; break;
    case FIL : dest = &pModDb->FIL[pProto->firstNdx]; break;
    // ...
}
memcpy(dest, pProto->data, pProto->dataLen);

enum DBENUM {
  DE_IVKK = 0,
  DE_FIL,
  DE_FDDD,
  DE_FCDCP,
  DE_FLH,
  // blah blah blah
};

BOOL DBCopyFunction (enun DBNUM whatToCopy, struct TModDB* TheDB, void* Buf, long SizeOfBuf){
   BOOL success = FALSE;    // Preset fail .. any errrors we will let drop thru
   if (TheDb){              // Check theDB ptr valid
      switch(whatToCopy){
          case DE_IVKK: {
              if (sizeof(TheDB->IVKK) <= SizeofBuf) {             // check buffer large enough
                   memcpy(Buf, TheDB->IVKK, sizeof(TheDB->IVKK)); // Copy IVK field
                   success = TRUE;                                // Field copied set success
              }
          }
          break;
          case DE_FIL: {
              if (sizeof(TheDB->FIL) <= SizeofBuf) {             // check buffer large enough
                   memcpy(Buf, TheDB->FIL, sizeof(TheDB->FIL));  // Copy FIL field
                   success = TRUE;                               // Field copied set success
              }
          }
          break;

          /// blah blah blah
      }
   }
   return (success);
} 

manoharbalu wrote:

Now I need to transfer some of the data values that are changed to another application...