catior.cpp

TAO学习工具

      str = subString.rep ();
      b = catiiop (str ACE_ENV_ARG_PARAMETER);
    }
  else if (aString.find (":IR:") > 0)
    {
      ACE_DEBUG ((LM_DEBUG,
                  "decoding an POOP IOR\n"));

      str = aString.rep ();
      b = catpoop (str ACE_ENV_ARG_PARAMETER);
    }
  else
    ACE_ERROR ((LM_ERROR,
                "Don't know how to decode this IOR\n"));
  return b;
}

int
ACE_TMAIN (int argcw, ACE_TCHAR *argvw[])
{
  ACE_DECLARE_NEW_CORBA_ENV;
  ACE_Argv_Type_Converter argcon (argcw, argvw);
  CORBA::ORB_var orb_var =  CORBA::ORB_init (argcon.get_argc (),
                                             argcon.get_ASCII_argv (),
                                             "TAO" ACE_ENV_ARG_PARAMETER);
  CORBA::Boolean b = 0;
  int opt;

  ACE_Get_Opt get_opt (argcon.get_argc (), argcon.get_TCHAR_argv (),
                       ACE_TEXT ("f:n:x"));

  while ((opt = get_opt ()) != -1)
    {
      switch (opt)
        {
        case ACE_TEXT('n'):
          //  Read the CosName from the NamingService convert the
          //  object_ptr to a CORBA::String_var via the call to
          //  object_to_string.
          ACE_DEBUG ((LM_DEBUG,
                      "opening a connection to the NamingService\n"
                      "resolving the CosName %s\n",
                      get_opt.opt_arg ()));
          break;
        case ACE_TEXT('f'):
          {
            //  Read the file into a CORBA::String_var.
            ACE_DEBUG ((LM_DEBUG,
                        "reading the file %s\n",
                        get_opt.opt_arg ()));

#if !defined (ACE_LACKS_IOSTREAM_TOTALLY)
            ifstream ifstr (ACE_TEXT_TO_CHAR_IN(get_opt.opt_arg ()));

            if (!ifstr.good ())
              {
                ifstr.close ();
                return -1;
              }

            int have_some_input = 0;
            while (!ifstr.eof())
              {
                char ch;
                ACE_CString aString;

                while (!ifstr.eof ())
                  {
                    ifstr.get (ch);
                    if (ch == '\n' || ifstr.eof ())
                      break;
                    aString += ch;
                    have_some_input = 1;
                  }
                if (have_some_input == 0 || !aString.length())
                  break;
                b = cat_from_string (aString ACE_ENV_ARG_PARAMETER);
                if (b == 1)
                  ACE_DEBUG ((LM_DEBUG,
                              "catior returned true\n"));
                else
                  ACE_DEBUG ((LM_DEBUG,
                              "catior returned false\n"));
              }
            ifstr.close ();
#else
            FILE* ifstr = ACE_OS::fopen (get_opt.opt_arg (), ACE_TEXT ("r"));

            if (ifstr && !ferror (ifstr))
              {
                if (ifstr)
                  ACE_OS::fclose (ifstr);
                return -1;
              }

            int have_some_input = 0;
            while (!feof (ifstr))
              {
                char ch;
                ACE_CString aString;

                while (!feof (ifstr))
                  {
                    ch = ACE_OS::fgetc (ifstr);
                    if (ch == '\n' || ch == EOF)
                      break;
                    aString += ch;
                    have_some_input = 1;
                  }
                if (have_some_input == 0 || !aString.length())
                  break;
                b = cat_from_string (aString ACE_ENV_ARG_PARAMETER);
                if (b == 1)
                  ACE_DEBUG ((LM_DEBUG,
                              "catior returned true\n"));
                else
                  ACE_DEBUG ((LM_DEBUG,
                              "catior returned false\n"));
              }
            ACE_OS::fclose (ifstr);
#endif /* !defined (ACE_LACKS_IOSTREAM_TOTALLY) */
          }
          break;
        case ACE_TEXT('x'):
          {
            //  Read the file into a CORBA::String_var.
            ACE_DEBUG ((LM_DEBUG,
                        "reading from stdin\n"));

#if !defined (ACE_LACKS_IOSTREAM_TOTALLY)
            if (!cin.good ())
              {
                return -1;
              }

            int have_some_input = 0;
            while (!cin.eof())
              {
                char ch;
                ACE_CString aString;

                while (!cin.eof ())
                  {
                    cin.get (ch);
                    if (ch == '\n' || cin.eof ())
                      break;
                    aString += ch;
                    have_some_input = 1;
                  }
                if (have_some_input == 0 || !aString.length())
                  break;
                b = cat_from_string (aString ACE_ENV_ARG_PARAMETER);
                if (b == 1)
                  ACE_DEBUG ((LM_DEBUG,
                              "catior returned true\n"));
                else
                  ACE_DEBUG ((LM_DEBUG,
                              "catior returned false\n"));
              }
#else
            FILE* ifstr = stdin;

            if (ifstr && !ferror (ifstr))
              {
                if (ifstr)
                  ACE_OS::fclose (ifstr);
                return -1;
              }

            int have_some_input = 0;
            while (!feof (ifstr))
              {
                char ch;
                ACE_CString aString;

                while (!feof (ifstr))
                  {
                    ch = ACE_OS::fgetc (ifstr);
                    if (ch == '\n' || ch == EOF)
                      break;
                    aString += ch;
                    have_some_input = 1;
                  }
                if (have_some_input == 0 || !aString.length())
                  break;
                b = cat_from_string (aString);
                if (b == 1)
                  ACE_DEBUG ((LM_DEBUG,
                              "catior returned true\n"));
                else
                  ACE_DEBUG ((LM_DEBUG,
                              "catior returned false\n"));
              }
#endif /* !defined (ACE_LACKS_IOSTREAM_TOTALLY) */
          }
          break;
        case ACE_TEXT('?'):
        case ACE_TEXT('h'):
        default:
          ACE_ERROR_RETURN ((LM_ERROR,
                             "Usage: %s "
                             "-f filename "
                             "-n CosName "
                             "\n"
                             "Reads an IOR "
                             "and dumps the contents to stdout "
                             "\n",
                             argvw[0]),
                            1);
        }
    }

  return 0;
}


static CORBA::Boolean
cat_tag_orb_type (TAO_InputCDR& stream) {
  CORBA::ULong length = 0;
  if (stream.read_ulong (length) == 0)
    return 1;

  TAO_InputCDR stream2 (stream, length);
  stream.skip_bytes(length);

  CORBA::ULong orbtype;

  stream2 >> orbtype;
  if (orbtype == TAO_ORB_TYPE) {
    ACE_DEBUG ((LM_DEBUG,
                "%I ORB Type: %d (TAO)\n",
                orbtype));
  } else {
    ACE_DEBUG ((LM_DEBUG,
                "%I ORB Type: %d\n",
                orbtype));
  }

  return 1;
}


static CORBA::Boolean
cat_tao_tag_endpoints (TAO_InputCDR& stream) {
  CORBA::ULong length = 0;
  if (stream.read_ulong (length) == 0)
    return 1;

  TAO_InputCDR stream2 (stream, length);
  stream.skip_bytes(length);

  TAO::IIOPEndpointSequence epseq;
  stream2 >> epseq;

  for (unsigned int iter=0; iter < epseq.length() ; iter++) {
    ACE_DEBUG ((LM_DEBUG,
                "%I Endpoint #%d:\n",iter+1));
    const char *host = epseq[iter].host;
    ACE_DEBUG ((LM_DEBUG,
                "%I Host: %s\n",host));
    unsigned short port = epseq[iter].port;
    ACE_DEBUG ((LM_DEBUG,
                "%I Port: %d\n",port));
    ACE_DEBUG ((LM_DEBUG,
                "%I Priority: %d\n",epseq[iter].priority));
  }

  return 1;
}

static CORBA::Boolean
cat_tag_alternate_endpoints (TAO_InputCDR& stream) {
  CORBA::ULong length = 0;
  if (stream.read_ulong (length) == 0)
    return 1;

  TAO_InputCDR stream2 (stream, length);
  stream.skip_bytes(length);

  CORBA::String_var host;
  CORBA::UShort port;
  if ((stream2  >> host.out()) == 0 ||
      (stream2 >> port) == 0)
    ACE_ERROR_RETURN ((LM_ERROR,"cannot extract endpoint info\n"),0);
  ACE_DEBUG ((LM_DEBUG,
              "%I endpoint: %s:%u\n",host.in(),port));
  return 1;
}


static CORBA::Boolean
cat_tag_policies (TAO_InputCDR& stream) {
  CORBA::ULong length = 0;
  if (stream.read_ulong (length) == 0)
    return 1;

  TAO_InputCDR stream2 (stream, length);
  stream.skip_bytes(length);

  Messaging::PolicyValueSeq policies;
  stream2 >> policies;

  ACE_DEBUG ((LM_DEBUG,
              "%I Number of policies: %d\n",
              policies.length()));

  for (unsigned int iter=0; iter < policies.length() ; iter++) {
    // Create new stream for pvalue contents
    char *pmbuf = new char [policies[iter].pvalue.length()];

    for (unsigned int biter=0 ;
         biter < policies[iter].pvalue.length() - sizeof(int) ;
         biter++) {
      pmbuf[biter] = policies[iter].pvalue[biter + sizeof(int)];
    }

    int byteOrder = policies[iter].pvalue[0];
    TAO_InputCDR stream3 (pmbuf,
                          policies[iter].pvalue.length(),
                          ACE_static_cast(int,byteOrder));

    if (policies[iter].ptype == RTCORBA::PRIORITY_MODEL_POLICY_TYPE) {
      ACE_DEBUG ((LM_DEBUG,
                  "%I Policy #%d Type: %d (PRIORITY_MODEL_POLICY_TYPE)\n",
                  iter+1,
                  policies[iter].ptype));

      RTCORBA::PriorityModel priority_model;
      RTCORBA::Priority server_priority;

      stream3 >> priority_model;
      stream3 >> server_priority;

      if (priority_model == RTCORBA::CLIENT_PROPAGATED) {
        ACE_DEBUG ((LM_DEBUG,"%I Priority Model: %d (CLIENT_PROPAGATED)\n",
                    priority_model));
      } else if (priority_model == RTCORBA::SERVER_DECLARED) {
        ACE_DEBUG ((LM_DEBUG,"%I Priority Model: %d (SERVER_DECLARED)\n",
                    priority_model));
      } else {
        ACE_DEBUG ((LM_DEBUG,"%I Priority Model: %d (UNKNOWN!)\n",
                    priority_model));
      }
      ACE_DEBUG ((LM_DEBUG,
                  "%I Priority: %d\n",
                  server_priority));

    } else if (policies[iter].ptype == Messaging::REBIND_POLICY_TYPE) {
      ACE_DEBUG ((LM_DEBUG,
                  "%I Policy #%d Type: %d (REBIND_POLICY_TYPE)\n",
                  iter+1,
                  policies[iter].ptype));
#if (TAO_HAS_SYNC_SCOPE_POLICY == 1)
    } else if (policies[iter].ptype == Messaging::SYNC_SCOPE_POLICY_TYPE) {
      ACE_DEBUG ((LM_DEBUG,
                  "%I Policy #%d Type: %d (SYNC_SCOPE_POLICY_TYPE)\n",
                  iter+1,
                  policies[iter].ptype));
#endif
    } else if (policies[iter].ptype == Messaging::REQUEST_PRIORITY_POLICY_TYPE) {
      ACE_DEBUG ((LM_DEBUG,
                  "%I Policy #%d Type: %d (REQUEST_PRIORITY_POLICY_TYPE)\n",
                  iter+1,
                  policies[iter].ptype));
    } else if (policies[iter].ptype == Messaging::REPLY_PRIORITY_POLICY_TYPE) {
      ACE_DEBUG ((LM_DEBUG,
                  "%I Policy #%d Type: %d (REPLY_PRIORITY_POLICY_TYPE)\n",
                  iter+1,
                  policies[iter].ptype));
    } else if (policies[iter].ptype == Messaging::REQUEST_START_TIME_POLICY_TYPE) {
      ACE_DEBUG ((LM_DEBUG,
                  "%I Policy #%d Type: %d (REQUEST_START_TIME_POLICY_TYPE)\n",
                  iter+1,
                  policies[iter].ptype));
    } else if (policies[iter].ptype == Messaging::REQUEST_END_TIME_POLICY_TYPE) {
      ACE_DEBUG ((LM_DEBUG,
                  "%I Policy #%d Type: %d (REQUEST_END_TIME_POLICY_TYPE)\n",
                  iter+1,
                  policies[iter].ptype));
    } else if (policies[iter].ptype == Messaging::REPLY_START_TIME_POLICY_TYPE) {
      ACE_DEBUG ((LM_DEBUG,
                  "%I Policy #%d Type: %d (REPLY_START_TIME_POLICY_TYPE)\n",
                  iter+1,
                  policies[iter].ptype));
    } else if (policies[iter].ptype == Messaging::REPLY_END_TIME_POLICY_TYPE) {
      ACE_DEBUG ((LM_DEBUG,
                  "%I Policy #%d Type: %d (REPLY_END_TIME_POLICY_TYPE)\n",
                  iter+1,
                  policies[iter].ptype));
    } else if (policies[iter].ptype == Messaging::RELATIVE_REQ_TIMEOUT_POLICY_TYPE) {
      ACE_DEBUG ((LM_DEBUG,
                  "%I Policy #%d Type: %d (RELATIVE_REQ_TIMEOUT_POLICY_TYPE)\n",
                  iter+1,
                  policies[iter].ptype));
    } else if (policies[iter].ptype == Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE) {
      ACE_DEBUG ((LM_DEBUG,
                  "%I Policy #%d Type: %d (RELATIVE_RT_TIMEOUT_POLICY_TYPE)\n",
                  iter+1,
                  policies[iter].ptype));
    } else if (policies[iter].ptype == Messaging::ROUTING_POLICY_TYPE) {
      ACE_DEBUG ((LM_DEBUG,
                  "%I Policy #%d Type: %d (ROUTING_POLICY_TYPE)\n",
                  iter+1,
                  policies[iter].ptype));
    } else if (policies[iter].ptype == Messaging::MAX_HOPS_POLICY_TYPE) {
      ACE_DEBUG ((LM_DEBUG,
                  "%I Policy #%d Type: %d (MAX_HOPS_POLICY_TYPE)\n",
                  iter+1,
                  policies[iter].ptype));
    } else if (policies[iter].ptype == Messaging::QUEUE_ORDER_POLICY_TYPE) {
      ACE_DEBUG ((LM_DEBUG,
                  "%I Policy #%d Type: %d (QUEUE_ORDER_POLICY_TYPE)\n",
                  iter+1,
                  policies[iter].ptype));
    } else {
      ACE_DEBUG ((LM_DEBUG,
                  "%I Policy #%d Type: %d (UNKNOWN)\n", iter+1,
                  policies[iter].ptype));
    }

    delete [] pmbuf;
  }

  return 1;
}

static CORBA::Boolean
cat_octet_seq (const char *object_name,
               TAO_InputCDR& stream)
{
  CORBA::ULong length = 0;
  if (stream.read_ulong (length) == 0)
    return 1;

  ACE_DEBUG ((LM_DEBUG,
              "%I %s len:\t%d\n",
              object_name,
              length));

  ACE_DEBUG ((LM_DEBUG,
              "%I %s as hex:\n",
              object_name));

  CORBA::Octet anOctet;
  char* objKey = CORBA::string_alloc (length + 1);

  short counter = -1;

  ACE_DEBUG ((LM_DEBUG, "%I "));
  u_int i = 0;

  for (; i < length; i++)
    {
      if (++counter == 16)
        {
          ACE_DEBUG ((LM_DEBUG, "\n%I "));
          counter = 0;
        }
      stream.read_octet (anOctet);

      ACE_DEBUG ((LM_DEBUG, "%02.2x ", anOctet));
      objKey[i] = (char) anOctet;
    }

  objKey[i] = '\0';

  ACE_DEBUG ((LM_DEBUG,
              "\n%I The %s as string:\n%I ",
              object_name));

  for (i = 0; i < length; i++)
    {
      char c = objKey[i];
      int tmp = (unsigned char) c; // isprint doesn't work with negative vals.(except EOF)
      if (ACE_OS::ace_isprint (tmp))
        ACE_DEBUG ((LM_DEBUG, "%c", c));
      else
        ACE_DEBUG ((LM_DEBUG, "."));
    }

  CORBA::string_free (objKey);
  ACE_DEBUG ((LM_DEBUG, "\n"));

  return 1;
}

static CORBA::Boolean
cat_object_key (TAO_InputCDR& stream)
{
  // ... and object key.