_giop.c

This directory contains source code for tcpdump, a tool for network monitoring and data acquisition

/*
 * Copyright (c) 1997 Broadcom Eireann Research Ltd.  All Rights Reserved
 *
 * Author: Ciaran Treanor
 *
 * Purpose:
 *     Analyse and print GIOP (General Inter-ORO Protocol) packets
 *
 * Notes:
 *
 *
 * $Log$
 * Revision 1.4  1998/06/11 20:20:40  ct
 * Added endianness support
 *
 * Revision 1.3  1998/06/10 16:25:56  ct
 * Made some sense of the v flags
 * Cleaned up output
 *
 * Revision 1.2  1998/04/29 17:26:33  ct
 * Fixed word alignment
 *
 * Revision 1.1  1997/05/24 12:15:17  ct
 * Initial revision
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <sys/time.h>

#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <netinet/ip_var.h>
#include <netinet/tcp.h>
#include <netinet/tcpip.h>

#include "interfac.h"
#include "a2name.h"
#include "giop.h"

#define SWAP_WORD(a) ( ((a) << 24) |              \
                      (((a) << 8) & 0x00ff0000) | \
                      (((a) >> 8) & 0x0000ff00) | \
                      ((u_int32_t)(a) >>24) )

u_int32_t gtohl (u_int32_t val, u_char little_endian)
{
#ifdef WORDS_BIGENDIAN
  return (little_endian ? SWAP_WORD (val) : val);
#else
  return (!little_endian ? SWAP_WORD (val) : val);
#endif
}

/*
 * There's gotta be a faster way to do this
 * Shouldn't have vflag check here
 */
u_char *print_object_key (int length, u_char * ptr)
{
  int i = 0;

  if (vflag > 0)
  {
    PUTCHAR ('\"');
    for (i = 0; i++ < length; ptr++)
    {
      if (!isprint(*ptr))
           PUTCHAR ('.');
      else if (*ptr == ' ')
           PUTCHAR ('_');
      else PUTCHAR (*ptr);
    }
    PUTS ("\" ");
  }
  else
    ptr += length;

  ptr += length % 4 ? 4 - length % 4 : 0; /* Word align */
  return (ptr);
}

u_char *skip_context (u_char *ptr)
{
  struct ServiceContext *context = (struct ServiceContext*) ptr;
  int    length = context->context_data._length;

  ptr = &context->context_data._buffer;
  ptr += length;
  ptr += length % 4 ? 4 - length % 4 : 0; /* Word align */
  return (ptr);
}

/*
 * Print GIOP packets
 */
void corba_giop_print (struct MessageHeader_1_x *header)
{
  struct Sequence            *seq;
  struct RequestHeader_1_0   *reqHeader_1_0;
  struct RequestHeader_1_1   *reqHeader_1_1;
  struct ReplyHeader         *repHeader;
  struct LocateRequestHeader *locReqHeader;
  struct LocateReplyHeader   *locRepHeader;

  OctetSequence *octetSeq = NULL;
  const struct SystemExceptionReplyBody *sysExRepBody;
  const int    little = header->flags;

  int    i, version;
  u_char *data;

  header->messageSize = gtohl (header->messageSize, little);
  if (vflag > 1)
     PRINTF ("%d.%d %d ",
             header->GIOPVersion.major,
             header->GIOPVersion.minor,
             header->messageSize);
  version = header->GIOPVersion.major << 8 | header->GIOPVersion.minor;

  switch (version)
  {
    case 0x0100:            /* 1.0 */
         if (vflag > 2)
            PRINTF ("%s ", header->flags ? "little" : "big");
         break;
    case 0x0101:            /* 1.1 */
         if (vflag > 2)
            PRINTF ("%s ", header->flags & 0x01 ? "little" : "big");
         if (header->flags & 0x02)
            PUTS ("frag ");
         break;
  }

  /* Really should use sizeof(MessageHeader_1_x but I've got
   * that extra payload byte in there
   */
#if 0
   if (length != header->messageSize+12)
   {
     PRINTF ("Increase snaplen to %d", header->messageSize+12);
     return;
   }
#endif

  switch (header->messageType)
  {
    case Request:
         PUTS ("Request ");

         /* Need to check this
          */
         seq = (struct Sequence*) &header->payload;
         data = (u_char*) &seq->payload;
         seq->numElements = gtohl (seq->numElements, little);
         for (i = 0; i < seq->numElements; i++)
             data = skip_context (data);

         switch (version)
         {
           case 0x0100:     /* 1.0 */
                reqHeader_1_0 = (struct RequestHeader_1_0*) data;
                reqHeader_1_0->request_id         = gtohl (reqHeader_1_0->request_id, little);
                reqHeader_1_0->object_key._length = gtohl (reqHeader_1_0->object_key._length, little);
                PRINTF ("%d ", reqHeader_1_0->request_id);
                if (!reqHeader_1_0->response_expected && vflag > 2)
                   PUTS ("oneway ");

                data = print_object_key (reqHeader_1_0->object_key._length,
                                         (u_char*)&reqHeader_1_0->object_key._buffer);
                octetSeq = (OctetSequence*)data; /* Should be String, but... */
                octetSeq->_length = gtohl (octetSeq->_length, little);
                if (vflag > 2)
                {
                  data += octetSeq->_length + 4; /* 4: skip octetSeq len word */
                  data += octetSeq->_length % 4 ? 4 - octetSeq->_length % 4 : 0; /* Word align */

                  PRINTF ("\"%s\" ", data + 4);  /* 4: skip principal octetSeq len word */
                }
                break;

           case 0x0101:     /* 1.1 */
                reqHeader_1_1 = (struct RequestHeader_1_1*) data;
                reqHeader_1_1->request_id         = gtohl (reqHeader_1_1->request_id, little);
                reqHeader_1_1->object_key._length = gtohl (reqHeader_1_1->object_key._length, little);
                PRINTF ("%d ", reqHeader_1_1->request_id);
                if (!reqHeader_1_1->response_expected && vflag > 2)
                   PUTS ("oneway ");

                data = print_object_key (reqHeader_1_1->object_key._length,
                                         (u_char *) & reqHeader_1_1->object_key._buffer);
                octetSeq = (OctetSequence*) data; /* Should be String, but... */
                octetSeq->_length = gtohl (octetSeq->_length, little);
                if (vflag > 2)
                {
                  data += octetSeq->_length + 4; /* 4: skip octetSeq len word */
                  data += octetSeq->_length % 4 ? 4 - octetSeq->_length % 4 : 0; /* Word align */
                  PRINTF ("\"%s\" ", data + 4);  /* 4: skip principal octetSeq len word */
                }
                break;
           default:
                PRINTF ("version %d?", version);
                return;
         }
         PRINTF ("\"%s\" ", &octetSeq->_buffer); /* Already null terminated */
         break;

    case Reply:
         PUTS ("Reply ");

         /* Need to check this
          */
         seq = (struct Sequence*) &header->payload;
         seq->numElements = gtohl (seq->numElements, little);
         data = (u_char*) &seq->payload;
         for (i = 0; i < seq->numElements; i++)
             data = skip_context (data);

         repHeader = (struct ReplyHeader*) data;
         repHeader->request_id   = gtohl (repHeader->request_id, little);
         repHeader->reply_status = gtohl (repHeader->reply_status, little);
         PRINTF ("%d ", repHeader->request_id);
         switch (repHeader->reply_status)
         {
           case NoException:
                PUTS ("NoException NA ");
                break;
           case UserException:
                octetSeq = (OctetSequence *) & repHeader->payload;
                /* Should be String */
                /* Already null terminated (repository_id) */
                PRINTF ("UserException \"%s\" ", &octetSeq->_buffer);
                break;
           case SystemException:
                PUTS ("SystemException ");
                sysExRepBody = (struct SystemExceptionReplyBody*) &repHeader->payload;
                /* Fix the SystemExceptionReplyBody in the header file
                 */
                PRINTF ("\"%s\":%X:%X ", &sysExRepBody->exception_id._buffer,
                        sysExRepBody->minor_code_value, sysExRepBody->completion_status);
                break;
           case LocationForward:
                PUTS ("LocationForward NA ");
                break;
         }
         break;

    case CancelRequest:
         /* Should be aligned OK since sizeof(MessageHeader) == 12 */
         PRINTF ("CancelRequest %d NA NA ", (u_int32_t) & header->payload);
         break;

    case LocateRequest:
         locReqHeader = (struct LocateRequestHeader *) &header->payload;
         locReqHeader->object_key._length = gtohl (locReqHeader->object_key._length, little);
         PRINTF ("LocateRequest %d ", locReqHeader->request_id);
         print_object_key (locReqHeader->object_key._length, (u_char *) & locReqHeader->object_key._buffer);
         PUTS ("NA ");
         break;

    case LocateReply:
         locRepHeader = (struct LocateReplyHeader *) &header->payload;
         locRepHeader->request_id = gtohl (locRepHeader->request_id, little);
         locRepHeader->locate_status = gtohl (locRepHeader->locate_status, little);
         PRINTF ("LocateReply %ld ", locRepHeader->request_id);
         switch (locRepHeader->locate_status)
         {
           case UnknownObject:
                PUTS ("UnknownObject NA ");
                break;
           case ObjectHere:
                PUTS ("ObjectHere NA ");
                break;
           case ObjectForward:
                PUTS ("ObjectForward NA ");
                break;
         }
         break;

    case CloseConnection:
         PUTS ("CloseConnection NA NA NA ");
         break;

    case MessageError:
         PUTS ("MessageError NA NA NA ");
         break;

    case Fragment:
         PUTS ("Fragment NA NA NA ");
         break;

    default:
         PRINTF ("UNKNOWN MESSAGE: %04x NA NA ", header->messageType);

  }
}