adding DS library

17 files changed, 1505 insertions, 0 deletions

diff --git a/TAO/tao/DiffServPolicy/Client_Network_Priority_Policy.cpp b/TAO/tao/DiffServPolicy/Client_Network_Priority_Policy.cpp
new file mode 100644
index 00000000000..49c324115cb
--- /dev/null
+++ b/TAO/tao/DiffServPolicy/Client_Network_Priority_Policy.cpp
@@ -0,0 +1,154 @@
+// $Id$
+
+#include "tao/DiffServPolicy/Client_Network_Priority_Policy.h"
+#include "tao/DiffServPolicy/DiffServPolicyC.h"
+#include "tao/ORB_Constants.h"
+#include "tao/SystemException.h"
+
+ACE_RCSID (DiffServPolicy,
+           Client_Network_Priority_Policy,
+           "$Id$")
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+TAO_Client_Network_Priority_Policy::TAO_Client_Network_Priority_Policy (void)
+  : ::CORBA::Object ()
+  , ::CORBA::Policy ()
+  , ::CORBA::LocalObject ()
+  , TAO::NetworkPriorityPolicy ()
+  , TAO_Local_RefCounted_Object ()
+  , request_diffserv_codepoint_ (0)
+  , reply_diffserv_codepoint_ (0)
+  , network_priority_model_ (TAO::NO_NETWORK_PRIORITY)
+{
+}
+
+TAO_Client_Network_Priority_Policy::TAO_Client_Network_Priority_Policy (
+  const TAO::DiffservCodepoint request_diffserv_codepoint,
+  const TAO::DiffservCodepoint reply_diffserv_codepoint,
+  TAO::NetworkPriorityModel network_priority_model)
+  : ::CORBA::Object ()
+  , ::CORBA::Policy ()
+  , ::CORBA::LocalObject ()
+  , TAO::NetworkPriorityPolicy ()
+  , TAO_Local_RefCounted_Object ()
+  , request_diffserv_codepoint_ (request_diffserv_codepoint)
+  , reply_diffserv_codepoint_ (reply_diffserv_codepoint)
+  , network_priority_model_ (network_priority_model)
+{
+}
+
+TAO_Client_Network_Priority_Policy::TAO_Client_Network_Priority_Policy (
+   const TAO_Client_Network_Priority_Policy &rhs)
+  : ::CORBA::Object ()
+  , ::CORBA::Policy ()
+  , ::CORBA::LocalObject ()
+  , TAO::NetworkPriorityPolicy ()
+  , TAO_Local_RefCounted_Object ()
+  , request_diffserv_codepoint_ (rhs.request_diffserv_codepoint_)
+  , reply_diffserv_codepoint_ (rhs.reply_diffserv_codepoint_)
+  , network_priority_model_ (rhs.network_priority_model_)
+{
+}
+
+CORBA::Policy_ptr
+TAO_Client_Network_Priority_Policy::create (const CORBA::Any &)
+{
+  CORBA::Policy_ptr policy = CORBA::Policy::_nil ();
+
+  ACE_NEW_THROW_EX (policy,
+                    TAO_Client_Network_Priority_Policy (),
+                    CORBA::NO_MEMORY (
+                      CORBA::SystemException::_tao_minor_code (
+                        TAO::VMCID,
+                        ENOMEM),
+                      CORBA::COMPLETED_NO));
+
+  return policy;
+}
+
+CORBA::PolicyType
+TAO_Client_Network_Priority_Policy::policy_type (void)
+{
+  return TAO::CLIENT_NETWORK_PRIORITY_TYPE;
+}
+
+TAO_Client_Network_Priority_Policy *
+TAO_Client_Network_Priority_Policy::clone (void) const
+{
+  TAO_Client_Network_Priority_Policy *copy = 0;
+  ACE_NEW_RETURN (copy,
+                  TAO_Client_Network_Priority_Policy (*this),
+                  0);
+  return copy;
+}
+
+TAO::DiffservCodepoint
+TAO_Client_Network_Priority_Policy::request_diffserv_codepoint (void)
+{
+  return this->request_diffserv_codepoint_;
+}
+
+void
+TAO_Client_Network_Priority_Policy::request_diffserv_codepoint (
+   TAO::DiffservCodepoint req_dscp)
+{
+  this->request_diffserv_codepoint_ = req_dscp;
+}
+
+TAO::DiffservCodepoint
+TAO_Client_Network_Priority_Policy::reply_diffserv_codepoint (void)
+{
+  return this->reply_diffserv_codepoint_;
+}
+
+void
+TAO_Client_Network_Priority_Policy::reply_diffserv_codepoint (
+   TAO::DiffservCodepoint reply_dscp)
+{
+  this->reply_diffserv_codepoint_ = reply_dscp;
+}
+
+TAO::NetworkPriorityModel
+TAO_Client_Network_Priority_Policy::network_priority_model (void)
+{
+  return this->network_priority_model_;
+}
+
+void
+TAO_Client_Network_Priority_Policy::network_priority_model (
+  TAO::NetworkPriorityModel npm)
+{
+  this->network_priority_model_ = npm;
+}
+
+CORBA::Policy_ptr
+TAO_Client_Network_Priority_Policy::copy (void)
+{
+  TAO_Client_Network_Priority_Policy* servant = 0;
+  ACE_NEW_THROW_EX (servant,
+                    TAO_Client_Network_Priority_Policy (*this),
+                    CORBA::NO_MEMORY ());
+
+  return servant;
+}
+
+void
+TAO_Client_Network_Priority_Policy::destroy (void)
+{
+}
+
+TAO_Cached_Policy_Type
+TAO_Client_Network_Priority_Policy::_tao_cached_type (void) const
+{
+  return TAO_CACHED_POLICY_CLIENT_NETWORK_PRIORITY;
+}
+
+TAO_Policy_Scope
+TAO_Client_Network_Priority_Policy::_tao_scope (void) const
+{
+  return static_cast<TAO_Policy_Scope> (TAO_POLICY_DEFAULT_SCOPE |
+                                        TAO_POLICY_CLIENT_EXPOSED);
+}
+
+TAO_END_VERSIONED_NAMESPACE_DECL
diff --git a/TAO/tao/DiffServPolicy/Client_Network_Priority_Policy.h b/TAO/tao/DiffServPolicy/Client_Network_Priority_Policy.h
new file mode 100644
index 00000000000..56e2d41a162
--- /dev/null
+++ b/TAO/tao/DiffServPolicy/Client_Network_Priority_Policy.h
@@ -0,0 +1,107 @@
+// -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file   Client_Network_Priority_Policy.h
+ *
+ *  $Id$
+ *
+ *
+ */
+//=============================================================================
+
+
+#ifndef TAO_CLIENT_NETWORK_PRIORITY_POLICY_H
+#define TAO_CLIENT_NETWORK_PRIORITY_POLICY_H
+
+#include /**/ "ace/pre.h"
+
+#include "tao/DiffServPolicy/DiffServPolicy_Export.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "tao/LocalObject.h"
+#include "tao/Basic_Types.h"
+#include "tao/DiffServPolicy/DiffServPolicyC.h"
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4250)
+#endif /* _MSC_VER */
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+/**
+ * @class TAO_Client_Network_Priority_Policy
+ *
+ * @brief Implementation class for TAO-specific Network Priority Policy.
+ *
+ * This policy is defined by a client application to specify the
+ * network priority model that it would like to follow, as well as
+ * the request DiffServ codepoint and reply DiffServ codepoint
+ * corresponding to the network priority model.
+ */
+class TAO_DiffServPolicy_Export TAO_Client_Network_Priority_Policy
+  : public TAO::NetworkPriorityPolicy,
+    public TAO_Local_RefCounted_Object
+{
+public:
+  /// Constructor.
+  TAO_Client_Network_Priority_Policy (void);
+
+  /// Constructor.
+  TAO_Client_Network_Priority_Policy (
+     const TAO::DiffservCodepoint request_diffserv_codepoint,
+     const TAO::DiffservCodepoint reply_diffserv_codepoint,
+     TAO::NetworkPriorityModel network_priority_model);
+
+  /// Copy constructor.
+  TAO_Client_Network_Priority_Policy (
+     const TAO_Client_Network_Priority_Policy &rhs);
+
+  /// Returns a copy of <this>.
+  TAO_Client_Network_Priority_Policy *clone (void) const;
+
+  TAO::DiffservCodepoint request_diffserv_codepoint (void);
+
+  void request_diffserv_codepoint (TAO::DiffservCodepoint req_dscp);
+
+  TAO::DiffservCodepoint reply_diffserv_codepoint (void);
+
+  void reply_diffserv_codepoint (TAO::DiffservCodepoint reply_dscp);
+
+  TAO::NetworkPriorityModel network_priority_model (void);
+
+  void network_priority_model (TAO::NetworkPriorityModel npm);
+
+  static CORBA::Policy_ptr create (const CORBA::Any &val);
+
+  CORBA::PolicyType policy_type (void);
+
+  CORBA::Policy_ptr copy (void);
+
+  void destroy (void);
+
+  // Return the cached policy type for this policy.
+  TAO_Cached_Policy_Type _tao_cached_type (void) const;
+
+  // Returns the scope at which this policy can be applied. See orbconf.h.
+  TAO_Policy_Scope _tao_scope (void) const;
+
+private:
+  /// The attribute
+  TAO::DiffservCodepoint request_diffserv_codepoint_;
+  TAO::DiffservCodepoint reply_diffserv_codepoint_;
+  TAO::NetworkPriorityModel network_priority_model_;
+};
+
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif /* _MSC_VER */
+
+#include /**/ "ace/post.h"
+#endif /* TAO_CLIENT_NETWORK_PRIORITY_POLICY_H */
diff --git a/TAO/tao/DiffServPolicy/DiffServPolicy.cpp b/TAO/tao/DiffServPolicy/DiffServPolicy.cpp
new file mode 100644
index 00000000000..afdd56aef12
--- /dev/null
+++ b/TAO/tao/DiffServPolicy/DiffServPolicy.cpp
@@ -0,0 +1,53 @@
+// @(#) $Id$
+
+#include "tao/DiffServPolicy/DiffServPolicy.h"
+#include "tao/DiffServPolicy/DiffServPolicy_ORBInitializer.h"
+#include "tao/DiffServPolicy/DiffServ_Protocols_Hooks.h"
+#include "tao/ORB_Core.h"
+#include "tao/ORBInitializer_Registry.h"
+#include "tao/PI/PI.h"
+
+ACE_RCSID (DiffServPolicy, DiffServPolicy, "$Id$")
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+int
+TAO_DiffServPolicy_Initializer::init (void)
+{
+  // TAO_ORB_Core::set_network_priority_protocols_hooks (
+    // "DS_Network_Priority_Protocols_Hooks");
+  ACE_Service_Config::process_directive (
+    ace_svc_desc_TAO_DS_Network_Priority_Protocols_Hooks);
+
+  PortableInterceptor::ORBInitializer_ptr temp_orb_initializer =
+  PortableInterceptor::ORBInitializer::_nil ();
+  PortableInterceptor::ORBInitializer_var orb_initializer;
+
+  try
+    {
+      /// Register the EndpointPolicy ORBInitializer.
+      ACE_NEW_THROW_EX (temp_orb_initializer,
+                        TAO_DiffServPolicy_ORBInitializer,
+                        CORBA::NO_MEMORY (
+                          CORBA::SystemException::_tao_minor_code (
+                            TAO::VMCID,
+                            ENOMEM),
+                          CORBA::COMPLETED_NO));
+
+      orb_initializer = temp_orb_initializer;
+
+      PortableInterceptor::register_orb_initializer (orb_initializer.in ());
+    }
+  catch (const ::CORBA::Exception& ex)
+    {
+      if (TAO_debug_level > 0)
+        {
+          ex._tao_print_exception ("Caught exception:");
+        }
+      return -1;
+    }
+
+  return 0;
+}
+
+TAO_END_VERSIONED_NAMESPACE_DECL
diff --git a/TAO/tao/DiffServPolicy/DiffServPolicy.h b/TAO/tao/DiffServPolicy/DiffServPolicy.h
new file mode 100644
index 00000000000..788e567e1ad
--- /dev/null
+++ b/TAO/tao/DiffServPolicy/DiffServPolicy.h
@@ -0,0 +1,50 @@
+// -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file   DiffServPolicy.h
+ *
+ *  $Id$
+ *
+ *  @author  Jaiganesh Balasubramanian <jai@dre.vanderbilt.edu>
+ *           Johnny Willemsen <jwillemsen@remedy.nl>
+ */
+//=============================================================================
+
+
+#ifndef TAO_DIFFSERVPOLICY_H
+#define TAO_DIFFSERVPOLICY_H
+
+#include /**/ "ace/pre.h"
+
+#include "tao/DiffServPolicy/DiffServPolicy_Export.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "tao/PI/PI.h"
+#include "tao/Versioned_Namespace.h"
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+class TAO_DiffServPolicy_Export TAO_DiffServPolicy_Initializer
+{
+public:
+  /// Used to force the initialization of the ORB code.
+  static int init (void);
+};
+
+static int
+TAO_Requires_DiffServPolicy_Initializer = 
+  TAO_DiffServPolicy_Initializer::init ();
+
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+#include /**/ "ace/post.h"
+
+#define TAO_DIFFSERVPOLICY_SAFE_INCLUDE
+#include "tao/DiffServPolicy/DiffServPolicyC.h"
+#undef TAO_DIFFSERVPOLICY_SAFE_INCLUDE
+
+#endif /* TAO_DIFFSERVPOLICY_H */
diff --git a/TAO/tao/DiffServPolicy/DiffServPolicy.pidl b/TAO/tao/DiffServPolicy/DiffServPolicy.pidl
new file mode 100644
index 00000000000..aee68884a08
--- /dev/null
+++ b/TAO/tao/DiffServPolicy/DiffServPolicy.pidl
@@ -0,0 +1,61 @@
+// -*- IDL -*-
+
+// ================================================================
+/**
+ *  @file DiffServPolicy.pidl
+ *
+ *  $Id$
+ *
+ *  This file contains TAO-specific idl interfaces for adding
+ *  network priority or DiffServ support (not part of CORBA
+ *  2.6).
+ *
+ *  The steps to regenerate the code are as follows:
+ *
+ * 1. Run the tao_idl compiler on the pidl file.  The command used for
+ *   this is:
+ *
+ *   tao_idl
+ *       -o orig -Gp -Gd -Ge 1 -GA -SS -Sci
+ *       -Wb,export_macro=TAO_Export
+ *       -Wb,pre_include="ace/pre.h"
+ *       -Wb,post_include="ace/post.h"
+ *       TAO_Network_Priority_Policy.pidl
+ *
+ * 2. The files are ready to use
+ */
+// ================================================================
+
+#ifndef TAO_DIFFSERV_POLICY_IDL
+#define TAO_DIFFSERV_POLICY_IDL
+
+#include "tao/Policy.pidl"
+
+#pragma prefix "tao"
+
+module TAO
+{
+  typedef long DiffservCodepoint;
+
+  enum NetworkPriorityModel
+  {
+    CLIENT_PROPAGATED_NETWORK_PRIORITY,
+    SERVER_DECLARED_NETWORK_PRIORITY,
+    NO_NETWORK_PRIORITY
+  };
+
+  const CORBA::PolicyType SERVER_NETWORK_PRIORITY_TYPE = 85;
+  const CORBA::PolicyType CLIENT_NETWORK_PRIORITY_TYPE = 86;
+  const CORBA::PolicyType NETWORK_PRIORITY_TYPE = 87;
+
+  local interface NetworkPriorityPolicy : CORBA::Policy
+    {
+      attribute NetworkPriorityModel network_priority_model;
+      attribute DiffservCodepoint request_diffserv_codepoint;
+      attribute DiffservCodepoint reply_diffserv_codepoint;
+    };
+};
+
+#pragma prefix ""
+
+#endif /* TAO_DIFFSERV_POLICY_IDL */
diff --git a/TAO/tao/DiffServPolicy/DiffServPolicy_Export.h b/TAO/tao/DiffServPolicy/DiffServPolicy_Export.h
new file mode 100644
index 00000000000..2c6f69d9411
--- /dev/null
+++ b/TAO/tao/DiffServPolicy/DiffServPolicy_Export.h
@@ -0,0 +1,58 @@
+
+// -*- C++ -*-
+// $Id$
+// Definition for Win32 Export directives.
+// This file is generated automatically by generate_export_file.pl -s TAO_DiffServPolicy
+// ------------------------------
+#ifndef TAO_DIFFSERVPOLICY_EXPORT_H
+#define TAO_DIFFSERVPOLICY_EXPORT_H
+
+#include "ace/config-all.h"
+
+#if defined (ACE_AS_STATIC_LIBS) && !defined (TAO_DIFFSERVPOLICY_HAS_DLL)
+#  define TAO_DIFFSERVPOLICY_HAS_DLL 0
+#endif /* ACE_AS_STATIC_LIBS && TAO_DIFFSERVPOLICY_HAS_DLL */
+
+#if !defined (TAO_DIFFSERVPOLICY_HAS_DLL)
+#  define TAO_DIFFSERVPOLICY_HAS_DLL 1
+#endif /* ! TAO_DIFFSERVPOLICY_HAS_DLL */
+
+#if defined (TAO_DIFFSERVPOLICY_HAS_DLL) && (TAO_DIFFSERVPOLICY_HAS_DLL == 1)
+#  if defined (TAO_DIFFSERVPOLICY_BUILD_DLL)
+#    define TAO_DiffServPolicy_Export ACE_Proper_Export_Flag
+#    define TAO_DIFFSERVPOLICY_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T)
+#    define TAO_DIFFSERVPOLICY_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
+#  else /* TAO_DIFFSERVPOLICY_BUILD_DLL */
+#    define TAO_DiffServPolicy_Export ACE_Proper_Import_Flag
+#    define TAO_DIFFSERVPOLICY_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T)
+#    define TAO_DIFFSERVPOLICY_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
+#  endif /* TAO_DIFFSERVPOLICY_BUILD_DLL */
+#else /* TAO_DIFFSERVPOLICY_HAS_DLL == 1 */
+#  define TAO_DiffServPolicy_Export
+#  define TAO_DIFFSERVPOLICY_SINGLETON_DECLARATION(T)
+#  define TAO_DIFFSERVPOLICY_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
+#endif /* TAO_DIFFSERVPOLICY_HAS_DLL == 1 */
+
+// Set TAO_DIFFSERVPOLICY_NTRACE = 0 to turn on library specific tracing even if
+// tracing is turned off for ACE.
+#if !defined (TAO_DIFFSERVPOLICY_NTRACE)
+#  if (ACE_NTRACE == 1)
+#    define TAO_DIFFSERVPOLICY_NTRACE 1
+#  else /* (ACE_NTRACE == 1) */
+#    define TAO_DIFFSERVPOLICY_NTRACE 0
+#  endif /* (ACE_NTRACE == 1) */
+#endif /* !TAO_DIFFSERVPOLICY_NTRACE */
+
+#if (TAO_DIFFSERVPOLICY_NTRACE == 1)
+#  define TAO_DIFFSERVPOLICY_TRACE(X)
+#else /* (TAO_DIFFSERVPOLICY_NTRACE == 1) */
+#  if !defined (ACE_HAS_TRACE)
+#    define ACE_HAS_TRACE
+#  endif /* ACE_HAS_TRACE */
+#  define TAO_DIFFSERVPOLICY_TRACE(X) ACE_TRACE_IMPL(X)
+#  include "ace/Trace.h"
+#endif /* (TAO_DIFFSERVPOLICY_NTRACE == 1) */
+
+#endif /* TAO_DIFFSERVPOLICY_EXPORT_H */
+
+// End of auto generated file.
diff --git a/TAO/tao/DiffServPolicy/DiffServPolicy_Factory.cpp b/TAO/tao/DiffServPolicy/DiffServPolicy_Factory.cpp
new file mode 100644
index 00000000000..3fed4990ac9
--- /dev/null
+++ b/TAO/tao/DiffServPolicy/DiffServPolicy_Factory.cpp
@@ -0,0 +1,62 @@
+#include "tao/DiffServPolicy/DiffServPolicy_Factory.h"
+
+ACE_RCSID (DiffServPolicy,
+           DiffServPolicy_Factory,
+           "$Id$")
+
+#include "tao/DiffServPolicy/Client_Network_Priority_Policy.h"
+#include "tao/DiffServPolicy/Server_Network_Priority_Policy.h"
+#include "tao/PolicyC.h"
+#include "tao/ORB_Constants.h"
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+CORBA::Policy_ptr
+TAO_DiffServ_PolicyFactory::create_policy (
+    CORBA::PolicyType type,
+    const CORBA::Any &value)
+{
+  if (type == TAO::CLIENT_NETWORK_PRIORITY_TYPE)
+    return TAO_Client_Network_Priority_Policy::create (value);
+
+  if (type == TAO::NETWORK_PRIORITY_TYPE)
+    return TAO_Server_Network_Priority_Policy::create (value);
+
+  throw ::CORBA::PolicyError (CORBA::BAD_POLICY_TYPE);
+}
+
+CORBA::Policy_ptr
+TAO_DiffServ_PolicyFactory::_create_policy (CORBA::PolicyType type)
+{
+  CORBA::Policy_ptr policy = CORBA::Policy::_nil ();
+
+  if (type == TAO::CLIENT_NETWORK_PRIORITY_TYPE)
+    {
+      ACE_NEW_THROW_EX (policy,
+                        TAO_Client_Network_Priority_Policy (),
+                        CORBA::NO_MEMORY (
+                          CORBA::SystemException::_tao_minor_code (
+                            TAO::VMCID,
+                            ENOMEM),
+                          CORBA::COMPLETED_NO));
+
+      return policy;
+    }
+
+  if (type == TAO::NETWORK_PRIORITY_TYPE)
+    {
+      ACE_NEW_THROW_EX (policy,
+                        TAO_Server_Network_Priority_Policy (),
+                        CORBA::NO_MEMORY (
+                          CORBA::SystemException::_tao_minor_code (
+                            TAO::VMCID,
+                            ENOMEM),
+                          CORBA::COMPLETED_NO));
+
+      return policy;
+    }
+
+  throw ::CORBA::PolicyError (CORBA::BAD_POLICY_TYPE);
+}
+
+TAO_END_VERSIONED_NAMESPACE_DECL
diff --git a/TAO/tao/DiffServPolicy/DiffServPolicy_Factory.h b/TAO/tao/DiffServPolicy/DiffServPolicy_Factory.h
new file mode 100644
index 00000000000..9c58492b252
--- /dev/null
+++ b/TAO/tao/DiffServPolicy/DiffServPolicy_Factory.h
@@ -0,0 +1,60 @@
+// -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file     DiffServPolicy_Factory.h
+ *
+ *  $Id$
+ *
+ *  @author  Jaiganesh Balasubramanian <jai@dre.vanderbilt.edu>
+ *  @author  Johnny Willemsen <jwillemsen@remedy.nl>
+ */
+//=============================================================================
+
+
+#ifndef TAO_DIFFSERV_POLICY_FACTORY_H
+#define TAO_DIFFSERV_POLICY_FACTORY_H
+
+#include /**/ "ace/pre.h"
+
+#include "tao/orbconf.h"
+#include "tao/DiffServPolicy/DiffServPolicy_Export.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "tao/PI/PI.h"
+#include "tao/LocalObject.h"
+
+// This is to remove "inherits via dominance" warnings from MSVC.
+// MSVC is being a little too paranoid.
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4250)
+#endif /* _MSC_VER */
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+/// Policy factory for all DiffServ related policies.
+class TAO_DiffServPolicy_Export TAO_DiffServ_PolicyFactory
+  : public virtual PortableInterceptor::PolicyFactory,
+    public virtual TAO_Local_RefCounted_Object
+{
+public:
+
+  CORBA::Policy_ptr create_policy (CORBA::PolicyType type,
+                                   const CORBA::Any &value);
+
+  CORBA::Policy_ptr _create_policy (CORBA::PolicyType type);
+};
+
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif /* _MSC_VER */
+
+#include /**/ "ace/post.h"
+
+#endif /* TAO_DIFFSERV_POLICY_FACTORY_H */
diff --git a/TAO/tao/DiffServPolicy/DiffServPolicy_ORBInitializer.cpp b/TAO/tao/DiffServPolicy/DiffServPolicy_ORBInitializer.cpp
new file mode 100644
index 00000000000..52532c410ad
--- /dev/null
+++ b/TAO/tao/DiffServPolicy/DiffServPolicy_ORBInitializer.cpp
@@ -0,0 +1,87 @@
+// $Id$
+
+#include "tao/DiffServPolicy/DiffServPolicy_ORBInitializer.h"
+#include "tao/DiffServPolicy/DiffServPolicyC.h"
+#include "tao/DiffServPolicy/DiffServPolicy_Factory.h"
+#include "tao/DiffServPolicy/DiffServ_Protocols_Hooks.h"
+#include "tao/ORB_Core.h"
+#include "tao/PI/ORBInitInfo.h"
+
+ACE_RCSID (DiffServPolicy,
+           DiffServPolicy_ORBInitializer,
+           "$Id$")
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+void
+TAO_DiffServPolicy_ORBInitializer::pre_init (
+    PortableInterceptor::ORBInitInfo_ptr)
+{
+}
+
+void
+TAO_DiffServPolicy_ORBInitializer::post_init (
+    PortableInterceptor::ORBInitInfo_ptr info)
+{
+  this->register_policy_factories (info);
+}
+
+void
+TAO_DiffServPolicy_ORBInitializer::register_policy_factories (
+  PortableInterceptor::ORBInitInfo_ptr info)
+{
+  if (CORBA::is_nil (this->policy_factory_.in ()))
+    {
+      PortableInterceptor::PolicyFactory_ptr policy_factory;
+      ACE_NEW_THROW_EX (policy_factory,
+                        TAO_DiffServ_PolicyFactory,
+                          CORBA::NO_MEMORY (
+                            CORBA::SystemException::_tao_minor_code (
+                              TAO::VMCID,
+                              ENOMEM),
+                            CORBA::COMPLETED_NO));
+
+      this->policy_factory_ = policy_factory;
+    }
+
+  // Bind the same policy factory to all DiffServ related policy
+  // types since a single policy factory is used to create each of
+  // the different types of DiffServ policies.
+  static CORBA::PolicyType const type[] = {
+    TAO::CLIENT_NETWORK_PRIORITY_TYPE,
+    TAO::NETWORK_PRIORITY_TYPE
+  };
+
+  const CORBA::PolicyType *end =
+    type + sizeof (type) / sizeof (type[0]);
+
+  for (CORBA::PolicyType const * i = type;
+       i != end;
+       ++i)
+    {
+      try
+        {
+          info->register_policy_factory (*i, this->policy_factory_.in ());
+        }
+      catch ( ::CORBA::BAD_INV_ORDER& ex)
+        {
+          if (ex.minor () == (CORBA::OMGVMCID | 16))
+            {
+              // The factory is already there, it happens because the
+              // magic initializer in PortableServer.cpp registers
+              // with the ORB multiple times.  This is an indication
+              // that we should do no more work in this
+              // ORBInitializer.
+              return;
+            }
+          throw;
+        }
+      catch ( ::CORBA::Exception&)
+        {
+          // Rethrow any other exceptions...
+          throw;
+        }
+    }
+}
+
+TAO_END_VERSIONED_NAMESPACE_DECL
diff --git a/TAO/tao/DiffServPolicy/DiffServPolicy_ORBInitializer.h b/TAO/tao/DiffServPolicy/DiffServPolicy_ORBInitializer.h
new file mode 100644
index 00000000000..74b3295c32c
--- /dev/null
+++ b/TAO/tao/DiffServPolicy/DiffServPolicy_ORBInitializer.h
@@ -0,0 +1,65 @@
+// -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file DiffServPolicy_ORBInitializer.h
+ *
+ *  $Id$
+ *
+ *  @author Jaiganesh Balasubramanian <jai@dre.vanderbilt.edu>
+ *          Johnny Willemsen <jwillemsen@remedy.nl>
+ */
+//=============================================================================
+
+
+#ifndef TAO_DIFFSERV_POLICY_ORB_INITIALIZER_H
+#define TAO_DIFFSERV_POLICY_ORB_INITIALIZER_H
+
+#include /**/ "ace/pre.h"
+
+#include "tao/DiffServPolicy/DiffServPolicy_Export.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "tao/PI/PI.h"
+#include "tao/LocalObject.h"
+
+// This is to remove "inherits via dominance" warnings from MSVC.
+// MSVC is being a little too paranoid.
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4250)
+#endif /* _MSC_VER */
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+/// DiffServ Policy ORB initializer.
+class TAO_DiffServPolicy_Export TAO_DiffServPolicy_ORBInitializer
+  : public virtual PortableInterceptor::ORBInitializer
+  , public virtual TAO_Local_RefCounted_Object
+{
+public:
+  virtual void pre_init (PortableInterceptor::ORBInitInfo_ptr info);
+
+  virtual void post_init (PortableInterceptor::ORBInitInfo_ptr info);
+
+private:
+
+  /// Register DiffServ policy factories.
+  void register_policy_factories (PortableInterceptor::ORBInitInfo_ptr info);
+
+private:
+  PortableInterceptor::PolicyFactory_var policy_factory_;
+};
+
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif /* _MSC_VER */
+
+#include /**/ "ace/post.h"
+
+#endif /* TAO_DIFFSERV_POLICY_ORB_INITIALIZER_H */
diff --git a/TAO/tao/DiffServPolicy/DiffServ_Network_Priority_Hook.cpp b/TAO/tao/DiffServPolicy/DiffServ_Network_Priority_Hook.cpp
new file mode 100644
index 00000000000..75ded365ad1
--- /dev/null
+++ b/TAO/tao/DiffServPolicy/DiffServ_Network_Priority_Hook.cpp
@@ -0,0 +1,106 @@
+// @(#) $Id$
+
+#include "tao/DiffServPolicy/DiffServ_Network_Priority_Hook.h"
+#include "tao/PortableServer/Root_POA.h"
+#include "tao/PortableServer/POA_Policy_Set.h"
+#include "tao/DiffServPolicy/Server_Network_Priority_Policy.h"
+#include "tao/DiffServPolicy/DiffServPolicyC.h"
+#include "tao/Service_Context.h"
+#include "tao/TAO_Server_Request.h"
+#include "tao/Network_Priority_Protocols_Hooks.h"
+#include "tao/ORB_Core.h"
+#include "tao/Connection_Handler.h"
+
+ACE_RCSID(DiffServPolicy,
+          DiffServ_Network_Priority_Hook,
+          "$Id$")
+
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+
+TAO_DiffServ_Network_Priority_Hook::~TAO_DiffServ_Network_Priority_Hook(void)
+{
+}
+
+void
+TAO_DiffServ_Network_Priority_Hook::update_network_priority (
+  TAO_Root_POA &poa, TAO_POA_Policy_Set &policy_set)
+{
+  for (CORBA::ULong i = 0; i < policy_set.num_policies (); i++)
+    {
+      CORBA::Policy_var policy = policy_set.get_policy_by_index (i);
+
+      if (policy->policy_type () == TAO::NETWORK_PRIORITY_TYPE)
+        {
+          ::TAO::NetworkPriorityPolicy_var npp
+            = ::TAO::NetworkPriorityPolicy::_narrow (policy);
+
+          if (!CORBA::is_nil (npp.in ()))
+            {
+              TAO::NetworkPriorityModel network_priority_model =
+                npp->network_priority_model ();
+
+              poa.cached_policies ().network_priority_model (
+                TAO::Portable_Server::Cached_Policies::NetworkPriorityModel (
+                  network_priority_model));
+
+              TAO::DiffservCodepoint request_diffserv_codepoint  =
+                npp->request_diffserv_codepoint ();
+
+              TAO::DiffservCodepoint reply_diffserv_codepoint  =
+                npp->reply_diffserv_codepoint ();
+
+              poa.cached_policies ().request_diffserv_codepoint (
+                request_diffserv_codepoint);
+              poa.cached_policies ().reply_diffserv_codepoint (
+                reply_diffserv_codepoint);
+            }
+        }
+    }
+}
+
+void
+TAO_DiffServ_Network_Priority_Hook::set_dscp_codepoint (
+  TAO_ServerRequest &req, TAO_Root_POA &poa)
+{
+  CORBA::Long dscp_codepoint;
+  TAO_Service_Context &request_service_context =
+    req.request_service_context ();
+
+  TAO_Network_Priority_Protocols_Hooks *nph =
+   poa.orb_core ().get_network_priority_protocols_hooks ();
+
+  TAO::Portable_Server::Cached_Policies::NetworkPriorityModel npm =
+    poa.cached_policies ().network_priority_model ();
+
+  if (npm == TAO::Portable_Server::Cached_Policies::
+             CLIENT_PROPAGATED_NETWORK_PRIORITY)
+    {
+      dscp_codepoint = nph->get_dscp_codepoint (request_service_context);
+    }
+  else if (npm == TAO::Portable_Server::Cached_Policies::
+                  SERVER_DECLARED_NETWORK_PRIORITY)
+    {
+      dscp_codepoint = poa.cached_policies ().reply_diffserv_codepoint ();
+    }
+  else
+    {
+      dscp_codepoint = 0;
+    }
+
+  TAO_Connection_Handler *connection_handler =
+    req.transport ()->connection_handler ();
+  connection_handler->set_dscp_codepoint (dscp_codepoint);
+}
+
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+ACE_FACTORY_DEFINE (TAO_DiffServPolicy, TAO_DiffServ_Network_Priority_Hook)
+ACE_STATIC_SVC_DEFINE (TAO_DiffServ_Network_Priority_Hook,
+                       ACE_TEXT ("TAO_Network_Priority_Hook"),
+                       ACE_SVC_OBJ_T,
+                       &ACE_SVC_NAME (TAO_DiffServ_Network_Priority_Hook),
+                       ACE_Service_Type::DELETE_THIS
+                       | ACE_Service_Type::DELETE_OBJ,
+                       0)
diff --git a/TAO/tao/DiffServPolicy/DiffServ_Network_Priority_Hook.h b/TAO/tao/DiffServPolicy/DiffServ_Network_Priority_Hook.h
new file mode 100644
index 00000000000..c27837e29a7
--- /dev/null
+++ b/TAO/tao/DiffServPolicy/DiffServ_Network_Priority_Hook.h
@@ -0,0 +1,60 @@
+// -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file    Diffserv_Network_Priority_Hook.h
+ *
+ *  $Id$
+ *
+ *  @author  Jaiganesh Balasubramanian <jai@dre.vanderbilt.edu>
+ *           Johnny Willemsen <jwillemsen@remedy.nl>
+ */
+//=============================================================================
+
+#ifndef TAO_DIFFSERV_NETWORK_PRIORITY_HOOK_H
+#define TAO_DIFFSERV_NETWORK_PRIORITY_HOOK_H
+
+#include /**/ "ace/pre.h"
+#include "ace/Service_Config.h"
+
+#include "tao/DiffServPolicy/DiffServPolicy_Export.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "tao/PortableServer/Network_Priority_Hook.h"
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+class TAO_DiffServPolicy_Export TAO_DiffServ_Network_Priority_Hook
+  : public TAO_Network_Priority_Hook
+{
+public:
+  virtual ~TAO_DiffServ_Network_Priority_Hook(void);
+
+  /// This function is a hook, that is called from the Root_POA's
+  /// constructor. It allows the POA to cache the server side network
+  /// priority policy, so that it can be used for sending replies with the
+  /// policy-specified DiffServ codepoint.
+  ///
+  void update_network_priority (TAO_Root_POA &poa, 
+                                TAO_POA_Policy_Set &poa_policy_set);
+
+  /// This function is a hook, that is used by the POA's servant dispatcher
+  /// when it tries to assign DiffServ codepoints on the replies.
+  ///
+  void set_dscp_codepoint (TAO_ServerRequest &req,
+                           TAO_Root_POA &poa);
+};
+
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+ACE_STATIC_SVC_DECLARE_EXPORT (TAO_DiffServPolicy,
+                               TAO_DiffServ_Network_Priority_Hook)
+ACE_FACTORY_DECLARE (TAO_DiffServPolicy, TAO_DiffServ_Network_Priority_Hook)
+
+
+#include /**/ "ace/post.h"
+
+#endif /* TAO_DIFFSERV_NETWORK_PRIORITY_HOOK_H */
diff --git a/TAO/tao/DiffServPolicy/DiffServ_Protocols_Hooks.cpp b/TAO/tao/DiffServPolicy/DiffServ_Protocols_Hooks.cpp
new file mode 100644
index 00000000000..dd9160767d1
--- /dev/null
+++ b/TAO/tao/DiffServPolicy/DiffServ_Protocols_Hooks.cpp
@@ -0,0 +1,192 @@
+#include "tao/DiffServPolicy/DiffServ_Protocols_Hooks.h"
+#include "tao/Stub.h"
+#include "tao/Profile.h"
+#include "tao/ORB_Core.h"
+#include "tao/Service_Context.h"
+#include "tao/CDR.h"
+#include "tao/DiffServPolicy/Client_Network_Priority_Policy.h"
+#include "ace/OS_NS_string.h"
+
+ACE_RCSID (DiffServPolicy,
+           DiffServ_Protocols_Hooks,
+           "$Id$")
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+TAO_DS_Network_Priority_Protocols_Hooks::
+TAO_DS_Network_Priority_Protocols_Hooks (void)
+  : orb_core_ (0)
+{
+}
+
+
+TAO_DS_Network_Priority_Protocols_Hooks::
+~TAO_DS_Network_Priority_Protocols_Hooks (void)
+{
+}
+
+void
+TAO_DS_Network_Priority_Protocols_Hooks::init_hooks (TAO_ORB_Core *orb_core)
+{
+  this->orb_core_ = orb_core;
+}
+
+void
+TAO_DS_Network_Priority_Protocols_Hooks::np_service_context (
+    TAO_Stub *stub,
+    TAO_Service_Context &service_context,
+    CORBA::Boolean restart)
+{
+  // If the restart flag is true, then this call for a
+  // reinvocation. We need not prepare the Service Context List once
+  // again. We can use the already existing one.
+  if (!restart)
+    {
+      CORBA::Policy_var cnpp =
+        stub->get_cached_policy (TAO_CACHED_POLICY_CLIENT_NETWORK_PRIORITY);
+
+      if (!CORBA::is_nil (cnpp.in ()))
+        {
+          TAO::NetworkPriorityPolicy_var cnp =
+            TAO::NetworkPriorityPolicy::_narrow (cnpp.in ());
+
+          TAO::DiffservCodepoint reply_diffserv_codepoint;
+          reply_diffserv_codepoint = cnp->reply_diffserv_codepoint ();
+
+          CORBA::Long rep_dscp_codepoint = reply_diffserv_codepoint;
+
+          this->add_rep_np_service_context_hook (service_context,
+                                                 rep_dscp_codepoint);
+        }
+    }
+}
+
+void
+TAO_DS_Network_Priority_Protocols_Hooks::add_rep_np_service_context_hook (
+   TAO_Service_Context &service_context,
+   CORBA::Long &dscp_codepoint)
+{
+  TAO_OutputCDR cdr;
+  if ((cdr << ACE_OutputCDR::from_boolean (TAO_ENCAP_BYTE_ORDER) == 0)
+      || (cdr << dscp_codepoint) == 0)
+    {
+      throw CORBA::MARSHAL ();
+    }
+
+  service_context.set_context (IOP::REP_NWPRIORITY, cdr);
+}
+
+const CORBA::Long
+TAO_DS_Network_Priority_Protocols_Hooks::get_dscp_codepoint (
+  TAO_Service_Context &sc)
+{
+  CORBA::Long dscp_codepoint = 0;
+  const IOP::ServiceContext *context;
+
+  if (sc.get_context (IOP::REP_NWPRIORITY, &context) == 1)
+    {
+      TAO_InputCDR cdr (reinterpret_cast
+                        <const char*>
+                        (context->context_data.get_buffer ()),
+                        context->context_data.length ());
+
+      CORBA::Boolean byte_order;
+      if ((cdr >> ACE_InputCDR::to_boolean (byte_order)) == 0)
+        {
+          throw (CORBA::MARSHAL ());
+        }
+      cdr.reset_byte_order (static_cast<int> (byte_order));
+
+      if ((cdr >> dscp_codepoint) == 0)
+        {
+          throw (CORBA::MARSHAL ());
+        }
+    }
+
+  return dscp_codepoint;
+}
+
+const CORBA::Long
+TAO_DS_Network_Priority_Protocols_Hooks::get_dscp_codepoint (
+  TAO_Stub *stub, CORBA::Object *object)
+{
+  CORBA::Long dscp = 0;
+  TAO::DiffservCodepoint diffserv_codepoint;
+  CORBA::Policy_var server_nw_priority_policy;
+
+  CORBA::Policy_var client_nw_priority_policy =
+    stub->get_cached_policy (
+        TAO_CACHED_POLICY_CLIENT_NETWORK_PRIORITY);
+
+  if (CORBA::is_nil (client_nw_priority_policy.in ()))
+    {
+      TAO_Stub *server_stub = object->_stubobj ();
+      TAO_MProfile server_profiles = server_stub->base_profiles ();
+      CORBA::PolicyList_var policy_list =
+        server_profiles.policy_list ();
+
+      CORBA::ULong length = policy_list->length ();
+
+      for (CORBA::ULong i = 0; i < length; ++i)
+        {
+          if (policy_list[i]->policy_type () == TAO::NETWORK_PRIORITY_TYPE)
+            {
+              server_nw_priority_policy =
+                CORBA::Policy::_duplicate (policy_list[i]);
+            }
+        }
+
+      if (CORBA::is_nil (server_nw_priority_policy.in ()))
+        {
+          return dscp;
+        }
+      else
+        {
+          TAO::NetworkPriorityPolicy_var npp =
+            TAO::NetworkPriorityPolicy::_narrow (
+              server_nw_priority_policy.in ());
+
+          if (!CORBA::is_nil (npp.in ()))
+            {
+              TAO::NetworkPriorityModel network_priority_model =
+                npp->network_priority_model ();
+
+              if (network_priority_model ==
+                  TAO::SERVER_DECLARED_NETWORK_PRIORITY)
+                {
+                  diffserv_codepoint =
+                    npp->request_diffserv_codepoint ();
+                  dscp = diffserv_codepoint;
+                  return dscp;
+                }
+            }
+        }
+    }
+  else
+    {
+      TAO::NetworkPriorityPolicy_var client_nw_priority =
+        TAO::NetworkPriorityPolicy::_narrow (client_nw_priority_policy.in ());
+       
+      if (!CORBA::is_nil (client_nw_priority.in ()))
+        {
+          diffserv_codepoint =
+            client_nw_priority->request_diffserv_codepoint ();
+          dscp = diffserv_codepoint;
+          return dscp;
+        }
+    }
+
+  return dscp;
+}
+
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+ACE_STATIC_SVC_DEFINE (TAO_DS_Network_Priority_Protocols_Hooks,
+                       ACE_TEXT ("DS_Network_Priority_Protocols_Hooks"),
+                       ACE_SVC_OBJ_T,
+                       &ACE_SVC_NAME (TAO_DS_Network_Priority_Protocols_Hooks),
+                       ACE_Service_Type::DELETE_THIS
+                       | ACE_Service_Type::DELETE_OBJ,
+                       0)
+ACE_FACTORY_DEFINE (TAO_DiffServPolicy,
+                    TAO_DS_Network_Priority_Protocols_Hooks)
diff --git a/TAO/tao/DiffServPolicy/DiffServ_Protocols_Hooks.h b/TAO/tao/DiffServPolicy/DiffServ_Protocols_Hooks.h
new file mode 100644
index 00000000000..20471e00304
--- /dev/null
+++ b/TAO/tao/DiffServPolicy/DiffServ_Protocols_Hooks.h
@@ -0,0 +1,91 @@
+// -*- C++ -*-
+
+// ===================================================================
+/**
+ *  @file   DiffServ_Protocols_Hooks.h
+ *
+ *  $Id$
+ *
+ *  @author Jaiganesh Balasubramanian <jai@dre.vanderbilt.edu>
+ *          Johnny Willemsen <jwillemsen@remedy.nl>
+ */
+// ===================================================================
+
+#ifndef TAO_DIFFSERV_PROTOCOLS_HOOKS_H
+#define TAO_DIFFSERVT_PROTOCOLS_HOOKS_H
+
+#include /**/ "ace/pre.h"
+
+#include "tao/orbconf.h"
+
+#include "tao/Network_Priority_Protocols_Hooks.h"
+#include "ace/Service_Config.h"
+#include "tao/DiffServPolicy/DiffServPolicy_Export.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+class TAO_DiffServPolicy_Export TAO_DS_Network_Priority_Protocols_Hooks
+      : public TAO_Network_Priority_Protocols_Hooks
+{
+public:
+
+  /// Constructor
+  TAO_DS_Network_Priority_Protocols_Hooks (void);
+
+  /// Destructor
+  virtual ~TAO_DS_Network_Priority_Protocols_Hooks (void);
+
+  /// Initialize the network priority protocols hooks instance.
+  void init_hooks (TAO_ORB_Core *orb_core);
+
+  /// This function is used by the client side ORB to figure out
+  /// the DiffServ codepoint that needs to be added to the request
+  /// to be sent to the server.
+  ///
+  const CORBA::Long get_dscp_codepoint (TAO_Stub *stub, CORBA::Object *object);
+
+  /// This function is used by the server side to figure out the
+  /// DiffServ codepoint that is attached and sent as part of the 
+  /// service context of the request from the client side.
+  /// Specifically, when CLIENT_PROPAGATED networ priority model
+  /// is followed, the clients sent the DiffServ codepoint, they
+  /// want the server to use in the reply, as a service context
+  /// entry in the request.
+  ///
+  const CORBA::Long get_dscp_codepoint (TAO_Service_Context &sc);
+
+  /// This function is called from the ORB_Core to add
+  /// network priority policy specific information on the request
+  /// service context. Specifically, when CLIENT_PROPAGATED network
+  /// priority model is used, the DiffServ codepoint that needs to be used
+  /// by the server side in the reply, is specified as a service context
+  /// entry, just like how RT-CORBA's CLIENT_PROPAGATED priority model works.
+  ///
+  void np_service_context (TAO_Stub *stub,
+                           TAO_Service_Context &service_context,
+                           CORBA::Boolean restart);
+
+  /// Helper function that is used by the np_service_context () method.
+  ///
+  void add_rep_np_service_context_hook (
+    TAO_Service_Context &service_context,
+    CORBA::Long &dscp_codepoint);
+
+protected:
+
+  TAO_ORB_Core *orb_core_;
+};
+
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+ACE_STATIC_SVC_DECLARE_EXPORT (TAO_DiffServPolicy,
+                               TAO_DS_Network_Priority_Protocols_Hooks)
+ACE_FACTORY_DECLARE (TAO_DiffServPolicy,
+                     TAO_DS_Network_Priority_Protocols_Hooks)
+
+#include /**/ "ace/post.h"
+#endif /* TAO_DIFFSERV_PROTOCOLS_HOOKS_H */
diff --git a/TAO/tao/DiffServPolicy/Server_Network_Priority_Policy.cpp b/TAO/tao/DiffServPolicy/Server_Network_Priority_Policy.cpp
new file mode 100644
index 00000000000..12420df0717
--- /dev/null
+++ b/TAO/tao/DiffServPolicy/Server_Network_Priority_Policy.cpp
@@ -0,0 +1,170 @@
+// $Id$
+
+#include "tao/DiffServPolicy/Server_Network_Priority_Policy.h"
+#include "tao/DiffServPolicy/DiffServPolicyC.h"
+#include "tao/SystemException.h"
+#include "tao/ORB_Constants.h"
+
+ACE_RCSID (DiffServPolicy,
+           Server_Network_Priority_Policy,
+           "$Id$")
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+TAO_Server_Network_Priority_Policy::TAO_Server_Network_Priority_Policy (void)
+  : ::CORBA::Object ()
+  , ::CORBA::Policy ()
+  , ::CORBA::LocalObject ()
+  , TAO::NetworkPriorityPolicy ()
+  , TAO_Local_RefCounted_Object ()
+  , request_diffserv_codepoint_ (0)
+  , reply_diffserv_codepoint_ (0)
+  , network_priority_model_ (TAO::NO_NETWORK_PRIORITY)
+{
+}
+
+TAO_Server_Network_Priority_Policy::~TAO_Server_Network_Priority_Policy (void)
+{
+}
+
+TAO_Server_Network_Priority_Policy::TAO_Server_Network_Priority_Policy (
+  const TAO::DiffservCodepoint &request_diffserv_codepoint,
+  const TAO::DiffservCodepoint &reply_diffserv_codepoint,
+  TAO::NetworkPriorityModel &network_priority_model)
+  : ::CORBA::Object ()
+  , ::CORBA::Policy ()
+  , ::CORBA::LocalObject ()
+  , TAO::NetworkPriorityPolicy ()
+  , TAO_Local_RefCounted_Object ()
+  , request_diffserv_codepoint_ (request_diffserv_codepoint)
+  , reply_diffserv_codepoint_ (reply_diffserv_codepoint)
+  , network_priority_model_ (network_priority_model)
+{
+}
+
+TAO_Server_Network_Priority_Policy::TAO_Server_Network_Priority_Policy (
+   const TAO_Server_Network_Priority_Policy &rhs)
+  : ::CORBA::Object ()
+  , ::CORBA::Policy ()
+  , ::CORBA::LocalObject ()
+  , TAO::NetworkPriorityPolicy ()
+  , TAO_Local_RefCounted_Object ()
+  , request_diffserv_codepoint_ (rhs.request_diffserv_codepoint_)
+  , reply_diffserv_codepoint_ (rhs.reply_diffserv_codepoint_)
+  , network_priority_model_ (rhs.network_priority_model_)
+{
+}
+
+CORBA::Policy_ptr
+TAO_Server_Network_Priority_Policy::create (const CORBA::Any &)
+{
+  CORBA::Policy_ptr policy = CORBA::Policy::_nil ();
+
+  ACE_NEW_THROW_EX (policy,
+                    TAO_Server_Network_Priority_Policy (),
+                    CORBA::NO_MEMORY (TAO::VMCID,
+                                      CORBA::COMPLETED_NO));
+  return policy;
+}
+
+CORBA::PolicyType
+TAO_Server_Network_Priority_Policy::policy_type (void)
+{
+  return TAO::NETWORK_PRIORITY_TYPE;
+}
+
+TAO_Server_Network_Priority_Policy *
+TAO_Server_Network_Priority_Policy::clone (void) const
+{
+  TAO_Server_Network_Priority_Policy *copy = 0;
+  ACE_NEW_RETURN (copy,
+                  TAO_Server_Network_Priority_Policy (*this),
+                  0);
+  return copy;
+}
+
+TAO::DiffservCodepoint
+TAO_Server_Network_Priority_Policy::request_diffserv_codepoint (void)
+{
+  return this->request_diffserv_codepoint_;
+}
+
+void
+TAO_Server_Network_Priority_Policy::request_diffserv_codepoint (
+   TAO::DiffservCodepoint req_dscp)
+{
+  this->request_diffserv_codepoint_ = req_dscp;
+}
+
+TAO::DiffservCodepoint
+TAO_Server_Network_Priority_Policy::reply_diffserv_codepoint (void)
+{
+  return this->reply_diffserv_codepoint_;
+}
+
+void
+TAO_Server_Network_Priority_Policy::reply_diffserv_codepoint (
+   TAO::DiffservCodepoint reply_dscp)
+{
+  this->reply_diffserv_codepoint_ = reply_dscp;
+}
+
+TAO::NetworkPriorityModel
+TAO_Server_Network_Priority_Policy::network_priority_model (void)
+{
+  return this->network_priority_model_;
+}
+
+void
+TAO_Server_Network_Priority_Policy::network_priority_model (
+  TAO::NetworkPriorityModel npm)
+{
+  this->network_priority_model_ = npm;
+}
+
+CORBA::Policy_ptr
+TAO_Server_Network_Priority_Policy::copy (void)
+{
+  TAO_Server_Network_Priority_Policy* servant = 0;
+  ACE_NEW_THROW_EX (servant,
+                    TAO_Server_Network_Priority_Policy (*this),
+                    CORBA::NO_MEMORY ());
+
+  return servant;
+}
+
+void
+TAO_Server_Network_Priority_Policy::destroy (void)
+{
+}
+
+TAO_Cached_Policy_Type
+TAO_Server_Network_Priority_Policy::_tao_cached_type (void) const
+{
+  return TAO_CACHED_POLICY_NETWORK_PRIORITY;
+}
+
+TAO_Policy_Scope
+TAO_Server_Network_Priority_Policy::_tao_scope (void) const
+{
+  return static_cast<TAO_Policy_Scope> (TAO_POLICY_DEFAULT_SCOPE |
+                  TAO_POLICY_CLIENT_EXPOSED);
+}
+
+CORBA::Boolean
+TAO_Server_Network_Priority_Policy::_tao_encode (TAO_OutputCDR &out_cdr)
+{
+  return ((out_cdr << request_diffserv_codepoint_) &&
+          (out_cdr << reply_diffserv_codepoint_) &&
+          (out_cdr << network_priority_model_));
+}
+
+CORBA::Boolean
+TAO_Server_Network_Priority_Policy::_tao_decode (TAO_InputCDR &in_cdr)
+{
+  return ((in_cdr >> request_diffserv_codepoint_) &&
+          (in_cdr >> reply_diffserv_codepoint_) &&
+          (in_cdr >> network_priority_model_));
+}
+
+TAO_END_VERSIONED_NAMESPACE_DECL
diff --git a/TAO/tao/DiffServPolicy/Server_Network_Priority_Policy.h b/TAO/tao/DiffServPolicy/Server_Network_Priority_Policy.h
new file mode 100644
index 00000000000..37b440dc4c5
--- /dev/null
+++ b/TAO/tao/DiffServPolicy/Server_Network_Priority_Policy.h
@@ -0,0 +1,118 @@
+// -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file   Server_Network_Priority_Policy.h
+ *
+ *  $Id$
+ *
+ *
+ */
+//=============================================================================
+
+
+#ifndef TAO_SERVER_NETWORK_PRIORITY_POLICY_H
+#define TAO_SERVER_NETWORK_PRIORITY_POLICY_H
+
+#include /**/ "ace/pre.h"
+
+#include "tao/DiffServPolicy/DiffServPolicy_Export.h"
+#include "tao/DiffServPolicy/DiffServPolicyC.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "tao/LocalObject.h"
+#include "tao/Basic_Types.h"
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4250)
+#endif /* _MSC_VER */
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+/**
+ * @class TAO_Server_Network_Priority_Policy
+ *
+ * @brief Implementation class for TAO-specific Network Priority Policy.
+ *
+ * This policy is defined by a server application to specify the
+ * network priority model that it would like to follow, as well as
+ * the request DiffServ codepoint and reply DiffServ codepoint
+ * corresponding to the network priority model.
+ */
+class TAO_DiffServPolicy_Export TAO_Server_Network_Priority_Policy
+  : public TAO::NetworkPriorityPolicy,
+    public TAO_Local_RefCounted_Object
+{
+public:
+
+  /// default constructor.
+  TAO_Server_Network_Priority_Policy (void);
+
+  /// Constructor.
+  TAO_Server_Network_Priority_Policy (
+     const TAO::DiffservCodepoint &request_diffserv_codepoint,
+     const TAO::DiffservCodepoint &reply_diffserv_codepoint,
+     TAO::NetworkPriorityModel &network_priority_model);
+
+  /// Copy constructor.
+  TAO_Server_Network_Priority_Policy (
+     const TAO_Server_Network_Priority_Policy &rhs);
+
+  /// Returns a copy of <this>.
+  TAO_Server_Network_Priority_Policy *clone (void) const;
+
+  TAO::DiffservCodepoint request_diffserv_codepoint (void);
+
+  void request_diffserv_codepoint (TAO::DiffservCodepoint req_dscp);
+
+  TAO::DiffservCodepoint reply_diffserv_codepoint (void);
+
+  void reply_diffserv_codepoint (TAO::DiffservCodepoint reply_dscp);
+
+  TAO::NetworkPriorityModel network_priority_model (void);
+
+  void network_priority_model (TAO::NetworkPriorityModel npm);
+
+  static CORBA::Policy_ptr create (const CORBA::Any &val);
+
+  CORBA::PolicyType policy_type (void);
+
+  CORBA::Policy_ptr copy (void);
+
+  void destroy (void);
+
+  // Return the cached policy type for this policy.
+  TAO_Cached_Policy_Type _tao_cached_type (void) const;
+
+  // Returns the scope at which this policy can be applied. See orbconf.h.
+  TAO_Policy_Scope _tao_scope (void) const;
+
+  /// This method writes a CDR representation of the object state.
+  CORBA::Boolean _tao_encode (TAO_OutputCDR &out_cdr);
+
+  /// This method reads the object state from a CDR representation.
+  CORBA::Boolean _tao_decode (TAO_InputCDR &in_cdr);
+
+protected:
+
+  virtual ~TAO_Server_Network_Priority_Policy (void);
+
+private:
+  /// The attributes
+  TAO::DiffservCodepoint request_diffserv_codepoint_;
+  TAO::DiffservCodepoint reply_diffserv_codepoint_;
+  TAO::NetworkPriorityModel network_priority_model_;
+};
+
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif /* _MSC_VER */
+
+#include /**/ "ace/post.h"
+#endif /* TAO_SERVER_NETWORK_PRIORITY_POLICY_H */
diff --git a/TAO/tao/DiffServPolicy/TAO_DiffServPolicy.pc.in b/TAO/tao/DiffServPolicy/TAO_DiffServPolicy.pc.in
new file mode 100644
index 00000000000..67d0a2f065a
--- /dev/null
+++ b/TAO/tao/DiffServPolicy/TAO_DiffServPolicy.pc.in
@@ -0,0 +1,11 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: TAO_DiffServPolicy
+Description: TAO DiffServPolicy Library
+Requires: TAO_PI, TAO_PortableServer, TAO
+Version: @VERSION@
+Libs: -L${libdir} -lTAO_DiffServPolicy
+Cflags: -I${includedir}