main.cpp

"More for C++" is a class library that provides some features that are usually common for object ori

//
//  This file is part of the "More for C++" library
//
//  Copyright (c) 1999-2003 by Thorsten Goertz ([e-mail])
//
//  The "More for C++" library is free software; you can redistribute it and/or
//  modify it under the terms of the license that comes with this package.
//
//  Read "license.txt" for more details.
//
//  THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
//  WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES
//  OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.

////////////////////////////////////////////////////////////////////////////////

#include <sys/shm.h>
#include <iostream.hpp>
#include "../../more/os/unix/unixsharedmemory.hpp"

using namespace more::os::unix_;
using namespace std;

////////////////////////////////////////////////////////////////////////////////

typedef UnixSharedMemory::Object::SegmentHeader SegmentHeader;
typedef UnixSharedMemory::Object::ChunkHeader ChunkHeader;
typedef unsigned char byte;

void printSeparator( );
void dumpSegment( int nSegmentId, SegmentHeader* );
void dumpChunk( size_t nChunkOffset, ChunkHeader* );

int main( size_t nArgs, const char*  pcArgV[] )
{
  const key_t  nRootKey = 0x16111966;
  int      nSegmentId = shmget( nRootKey, 0, 0600 );

  if( nSegmentId == -1 )
  {
    cout << "Unable to retrieve root segment" << endl;
  }
  else
  {
    while( nSegmentId > 0 )
    {
      void* pSegmentHeaderVoid = shmat( nSegmentId, 0, 0 );

      if( ( size_t ) pSegmentHeaderVoid == 0xFFFFFFFF )
      {
        cout << "Segment could not be attached!" << endl;
        nSegmentId = 0;
      }
      else
      {
        SegmentHeader* pSegmentHeader = ( SegmentHeader* ) pSegmentHeaderVoid;

        if( pSegmentHeader -> m_nMagic != 0x22021969 )
        {
          cout << "Magic number not found!" << endl;
          nSegmentId = 0;
        }
        else
        {
          size_t  nChunkOffset = 0;
          size_t  nMaxOffset = pSegmentHeader -> m_nSize - sizeof( SegmentHeader );
          byte*  pBytes = ( byte* ) ( pSegmentHeader + 1 );

          dumpSegment( nSegmentId, pSegmentHeader );

          while( nChunkOffset < nMaxOffset )
          {
            ChunkHeader* pChunkHeader = ( ChunkHeader* ) ( pBytes + nChunkOffset );

            dumpChunk( nChunkOffset, pChunkHeader );
            nChunkOffset += pChunkHeader -> m_nChunkSize;
          }
        }

        printSeparator( );

        nSegmentId = pSegmentHeader -> m_nNextSegment;

        shmdt( pSegmentHeaderVoid );
      }
    }
  }

  cout << endl;

  return 0;
}

void printSeparator( )
{
  cout << "----------------------------" << endl;
}

////////////////////////////////////////////////////////////////////////////////

void dumpSegment( int nSegmentId, SegmentHeader* pSegmentHeader )
{
  printSeparator( );
  cout << "Segment id:      " << nSegmentId << endl;
  cout << "Size of segment: " << pSegmentHeader -> m_nSize << endl;
}

////////////////////////////////////////////////////////////////////////////////

void dumpChunk( size_t nChunkOffset, ChunkHeader* pChunkHeader )
{
  printSeparator( );
  cout << "Chunk offset:    " << nChunkOffset << endl;
  cout << "Chunk in use:    " << pChunkHeader -> m_bInUse << endl;
  cout << "Size of chunk:   " << pChunkHeader -> m_nChunkSize << endl;
  cout << "Size of object:  " << pChunkHeader -> m_nObjectSize << endl;
}

////////////////////////////////////////////////////////////////////////////////