Access violation at ABABABAB after realloc

I ran into this error and I don't quite understand what happens here. I hope the codesnippet is sufficient to make my point.

I am modifying a callback to inject my own data into a response to a server.

Basically the callstack looks as follows:

mainRoutine(browseFunction(browseInternal), myBrowseFunction))
            ^ takes response    ^ sends response    ^ catches and modifies response 
              and sends callback

So what happens: I have a server and a few hundred static nodes to be read. Now I want to support a highly dynamic messagingsystem, creating a node takes 300kb so is not an option as they are ten thousands, created and deleted within seconds. Therefore I inject the message into the response and pretend a node was read.

So much for the theory. This system worked in other context already, so there is no doubt the server can handle the fake response...

Some code - written in c++ but with the serverstack in C there are no new() or delete() methods available. All variables are initialized and filled with sensible values, as far as possible.

volatile int pNoOfNodesToAppend = 5;

Boolean xAdapter::Browse(BaseNode *pNode, BrowseContext* pBrowseCtx, int i)
{

  [... some initializations....] 

  BrowseResult* pBrowseResult = &pResponse->Results[i];

  int NoOfReferences = pBrowseResult->NoOfReferences + pNoOfNodesToAppend; 
  pResponse->NoOfResults = NoOfReferences;

// Version one
  ReferenceDescription* refDesc =  reinterpret_cast <ReferenceDescription *>(realloc(
     pBrowseResult->References,
     sizeof(OpcUa_ReferenceDescription) * NoOfReferences));



//Version two I tried just out of curiousity to see whether copying "by hand" would cause the programm to crash, as it didn't allocate enough memory - but no problem there.  
/*    
    ReferenceDescription* refDesc = reinterpret_cast <ReferenceDescription *>(malloc( NoOfReferences * sizeof(ReferenceDescription)));

    for (int k = 0; k < NoOfReferences; k++)
    {
       memcpy(&pBrowseResult->References[0], &pBrowseResult->References[k], sizeof(ReferenceDescription)); 
    }
*/


    int size = _msize(refDesc);
    pBrowseResult->NoOfReferences = NoOfReferences;

    if (refDesc != NULL)
    {
     pBrowseResult->References = refDesc; 
    }
    else 
    {
      return False;
      /*  Errorhandling  ... */
    }


  [Fill with data... check for errors, handle errors]

  return True;
}

I know this code looks cumbersome, but most of it cannot be done easier due to the underlying stack, as it gives me a hard time casting types to and forth, containing lots and lots of structures.

This code compiles and runs fine, once the callback is sent it crashes with an access violation at ABABABAB, which as I found out is a magic number used by Microsoft debug to mark guard bits around heapAlloc() memory (4 bits before and after). See here: Magic_debug_values 1

Edit: This section is solved. I was just too blind to realize that we are talking about HEX here and thus too dumb to calculate my numbers correctly. So consider it unworthy of reading except for understanding of comments.

What really gives me headache is the memsize of the allocated new array.

NoOfReferences:    6

sizeof(ReferenceDescription)                    0x00000080      unsigned int
(NoOfReferences * sizeof(ReferenceDescription)) 0x00000300  unsigned long

sizeof(*refDesc)     0x00000080 unsigned int //pointer to first element of array
_msize says: 
size of (*refDesc)   0x00000300 int

Now WHY is the size of the newly allocated space 300? If my mind is not playing tricks on me then 6*80 is 480, even if there where 8 guard bits around every single element it would still be 72*6 > 300 bit. Anyway the system proceeds normally.

Now in the next chunk of code the structures in the array are filled with useful data and handed back to the Response structure.

The Callback is sent, the server ist going back to the ServerMain() and then crashes with first chance and unhandled exception

Unhandled exception at 0x5f95ed6a in demoserver.exe: 0xC0000005: Access violation reading location 0xabababab.

Memory

0x5F95ED6A  f3 a5 ff 24 95 84 ee 95 5f 90 8b c7 ba 03 00 00 00 83 e9 04 72  ó¥ÿ$..î._..Ǻ....ƒé.r
0x5F95ED7F  0c 83 e0 03 03 c8 ff 24 85 98 ed 95 5f ff 24 8d 94 ee 95 5f 90  .ƒà..Èÿ$.˜í._ÿ$.”î._.
0x5F95ED94  ff 24 8d 18 ee 95 5f 90 a8 ed 95 5f d4 ed 95 5f f8 ed 95 5f 23  ÿ$..î._.¨í._Ôí._øí._#
0x5F95EDA9  d1 8a 06 88 07 8a 46 01 88 47 01 8a 46 02 c1 e9 02 88 47 02 83  ÑŠ.ˆ.ŠF.ˆG.ŠF.Áé.ˆG.ƒ
0x5F95EDBE  c6 03 83 c7 03 83 f9 08 72 cc f3 a5 ff 24 95 84 ee 95 5f 8d 49  Æ.ƒÇ.ƒù.rÌó¥ÿ$..î._.I
0x5F95EDD3  00 23 d1 8a 06 88 07 8a 46 01 c1 e9 02 88 47 01 83 c6 02 83 c7  .#ÑŠ.ˆ.ŠF.Áé.ˆG.ƒÆ.ƒÇ
0x5F95EDE8  02 83 f9 08 72 a6 f3 a5 ff 24 95 84 ee 95 5f 90 23 d1 8a 06 88  .ƒù.r¦ó¥ÿ$..î._.#ÑŠ.ˆ
0x5F95EDFD  07 83 c6 01 c1 e9 02 83 c7 01 83 f9 08 72 88 f3 a5 ff 24 95 84  .ƒÆ.Áé.ƒÇ.ƒù.rˆó¥ÿ$..
0x5F95EE12  ee 95 5f 8d 49 00 7b ee 95 5f 68 ee 95 5f 60 ee 95 5f 58 ee 95  î._.I.{î._hî._`î._Xî.
0x5F95EE27  5f 50 ee 95 5f 48 ee 95 5f 40 ee 95 5f 38 ee 95 5f 8b 44 8e e4  _Pî._Hî._@î._8î._.DŽä
0x5F95EE3C  89 44 8f e4 8b 44 8e e8 89 44 8f e8 8b 44 8e ec 89 44 8f ec 8b  .D.ä.DŽè.D.è.DŽì.D.ì.
0x5F95EE51  44 8e f0 89 44 8f f0 8b 44 8e f4 89 44 8f f4 8b 44 8e f8 89 44  DŽð.D.ð.DŽô.D.ô.DŽø.D
0x5F95EE66  8f f8 8b 44 8e fc 89 44 8f fc 8d 04 8d 00 00 00 00 03 f0 03 f8  .ø.DŽü.D.ü........ð.ø
0x5F95EE7B  ff 24 95 84 ee 95 5f 8b ff 94 ee 95 5f 9c ee 95 5f a8 ee 95 5f  ÿ$..î._.ÿ”î._œî._¨î._
0x5F95EE90  bc ee 95 5f 8b 45 08 5e 5f c9 c3 90 8a 06 88 07 8b 45 08 5e 5f  .î._.E.^_ÉÃ.Š.ˆ..E.^_
0x5F95EEA5  c9 c3 90 8a 06 88 07 8a 46 01 88 47 01 8b 45 08 5e 5f c9 c3 8d  ÉÃ.Š.ˆ.ŠF.ˆG..E.^_ÉÃ.

So the mistake was found. The problem was neither the allocation nor the reassignment of the array but rather the fact, that the API didn't behave as expected and marshalled several callbacks. Trying to add mine by appeding it crashed and caused the exception as it was not ment to be done that way. (Solution and structure would be too complex to post it here.)

Thank you for your time and hints anyway, I learned a lot while chasing the errors!