dep/ACE_wrappers/ace/ATM_QoS.cpp

   1 // $Id: ATM_QoS.cpp 80826 2008-03-04 14:51:23Z wotte $
   2
   3 #include "ace/ATM_QoS.h"
   4
   5 ACE_RCSID(ace, ATM_QoS, "$Id: ATM_QoS.cpp 80826 2008-03-04 14:51:23Z wotte $")
   6
   7 #if defined (ACE_HAS_ATM)
   8
   9 #if !defined (__ACE_INLINE__)
  10 #include "ace/ATM_QoS.inl"
  11 #endif /* __ACE_INLINE__ */
  12
  13 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  14
  15 #if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
  16 #define BHLI_MAGIC "FORE_ATM"
  17 // This is line rate in cells/s for an OC-3 MM interface.
  18 const long ACE_ATM_QoS::LINE_RATE = 353207;
  19 const int ACE_ATM_QoS::OPT_FLAGS_CPID = 0x1;
  20 const int ACE_ATM_QoS::OPT_FLAGS_PMP = 0x2;
  21 const int ACE_ATM_QoS::DEFAULT_SELECTOR = 0x99;
  22 const int ACE_ATM_QoS::DEFAULT_PKT_SIZE = 8192;
  23 #elif defined (ACE_HAS_LINUX_ATM)
  24 //pbrandao:for Linux:
  25 //pbrandao:for now stick with current definitions
  26 //pbrandao:see if later need to change
  27 const long ACE_ATM_QoS::LINE_RATE = 353207;
  28 const int ACE_ATM_QoS::OPT_FLAGS_CPID = 0x1;
  29 const int ACE_ATM_QoS::OPT_FLAGS_PMP = 0x2;
  30 const int ACE_ATM_QoS::DEFAULT_SELECTOR = 0x99;
  31 const int ACE_ATM_QoS::DEFAULT_PKT_SIZE = 8192;
  32 #else
  33 const long ACE_ATM_QoS::LINE_RATE = 0L;
  34 const int ACE_ATM_QoS::OPT_FLAGS_CPID = 0;
  35 const int ACE_ATM_QoS::OPT_FLAGS_PMP = 0;
  36 const int ACE_ATM_QoS::DEFAULT_SELECTOR = 0x0;
  37 const int ACE_ATM_QoS::DEFAULT_PKT_SIZE = 0;
  38 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
  39
  40 ACE_ALLOC_HOOK_DEFINE(ACE_ATM_QoS)
  41
  42 ACE_ATM_QoS::ACE_ATM_QoS (int pktSize)
  43 {
  44   ACE_TRACE ("ACE_ATM_QoS::ACE_ATM_QoS");
  45 #if defined (ACE_HAS_LINUX_ATM)
  46     ACE_OS::memset(&qos_, 0, sizeof(qos_));
  47     qos_.aal = ATM_PROTOCOL_DEFAULT;
  48     qos_.rxtp.traffic_class = ATM_ANYCLASS;
  49     qos_.rxtp.max_sdu = pktSize;
  50     qos_.txtp.traffic_class = ATM_ANYCLASS;
  51     qos_.txtp.max_sdu = pktSize;
  52 #else
  53     ACE_UNUSED_ARG (pktSize);
  54 #endif /* ACE_HAS_LINUX_ATM */
  55 }
  56
  57 ACE_ATM_QoS::ACE_ATM_QoS(int rate,
  58                          int pktSize)
  59 {
  60   ACE_TRACE( "ACE_ATM_QoS::ACE_ATM_QoS" );
  61 #if defined (ACE_HAS_FORE_ATM_WS2)
  62   AAL_PARAMETERS_IE ie_aalparams;
  63   ATM_TRAFFIC_DESCRIPTOR_IE ie_td;
  64   ATM_BROADBAND_BEARER_CAPABILITY_IE ie_bbc;
  65   ATM_QOS_CLASS_IE ie_qos;
  66   Q2931_IE *ie_ptr;
  67   int size;
  68
  69   // Setting up cbr parameters ...
  70   ie_aalparams.AALType = AALTYPE_5;
  71   ie_aalparams.AALSpecificParameters.AAL5Parameters.ForwardMaxCPCSSDUSize
  72     = pktSize; // was 1516;
  73   ie_aalparams.AALSpecificParameters.AAL5Parameters.BackwardMaxCPCSSDUSize
  74     = pktSize; // was 1516;
  75   ie_aalparams.AALSpecificParameters.AAL5Parameters.Mode = AAL5_MODE_MESSAGE;
  76   ie_aalparams.AALSpecificParameters.AAL5Parameters.SSCSType = AAL5_SSCS_NULL;
  77
  78   size = sizeof(Q2931_IE_TYPE) + sizeof(ULONG) + sizeof(AAL_PARAMETERS_IE);
  79
  80   ie_td.Forward.PeakCellRate_CLP0 = SAP_FIELD_ABSENT;
  81   ie_td.Forward.PeakCellRate_CLP01 = rate;
  82   ie_td.Forward.SustainableCellRate_CLP0 = SAP_FIELD_ABSENT;
  83   ie_td.Forward.SustainableCellRate_CLP01 = SAP_FIELD_ABSENT;
  84   ie_td.Forward.MaxBurstSize_CLP0 = SAP_FIELD_ABSENT;
  85   ie_td.Forward.MaxBurstSize_CLP01 = SAP_FIELD_ABSENT;
  86   ie_td.Forward.Tagging = SAP_FIELD_ABSENT;
  87
  88   ie_td.Backward.PeakCellRate_CLP0 = SAP_FIELD_ABSENT;
  89   ie_td.Backward.PeakCellRate_CLP01 = rate;
  90   ie_td.Backward.SustainableCellRate_CLP0 = SAP_FIELD_ABSENT;
  91   ie_td.Backward.SustainableCellRate_CLP01 = SAP_FIELD_ABSENT;
  92   ie_td.Backward.MaxBurstSize_CLP0 = SAP_FIELD_ABSENT;
  93   ie_td.Backward.MaxBurstSize_CLP01 = SAP_FIELD_ABSENT;
  94   ie_td.Backward.Tagging = SAP_FIELD_ABSENT;
  95
  96   ie_td.BestEffort = 0; // Note: this must be set to zero for CBR.
  97
  98   size += sizeof( Q2931_IE_TYPE )
  99     + sizeof( ULONG )
 100     + sizeof( ATM_TRAFFIC_DESCRIPTOR_IE );
 101
 102   ie_bbc.BearerClass = BCOB_X;
 103   ie_bbc.TrafficType = TT_CBR;
 104   ie_bbc.TimingRequirements = TR_END_TO_END;
 105   ie_bbc.ClippingSusceptability = CLIP_NOT;
 106   ie_bbc.UserPlaneConnectionConfig = UP_P2P;
 107
 108   size += sizeof( Q2931_IE_TYPE )
 109     + sizeof( ULONG )
 110     + sizeof( ATM_BROADBAND_BEARER_CAPABILITY_IE );
 111
 112   ie_qos.QOSClassForward = QOS_CLASS1;
 113   ie_qos.QOSClassBackward = QOS_CLASS1; // This may not be really used
 114   // since we do only simplex data xfer.
 115
 116   size += sizeof(Q2931_IE_TYPE) + sizeof(ULONG) + sizeof(ATM_QOS_CLASS_IE);
 117
 118   qos_.ProviderSpecific.buf = (char *) ACE_OS::malloc(size);
 119   if (qos_.ProviderSpecific.buf == 0) {
 120     ACE_ERROR((LM_ERROR,
 121                ACE_TEXT ("ACE_ATM_QoS::ACE_ATM_QoS: Unable to allocate %d bytes for qos_.ProviderSpecific.buf\n"),
 122                size));
 123     return;
 124   }
 125   qos_.ProviderSpecific.len = size;
 126   ACE_OS::memset(qos_.ProviderSpecific.buf, 0, size);
 127
 128   ie_ptr = (Q2931_IE *) qos_.ProviderSpecific.buf;
 129   ie_ptr->IEType = IE_AALParameters;
 130   ie_ptr->IELength = sizeof( Q2931_IE_TYPE )
 131     + sizeof( ULONG )
 132     + sizeof( AAL_PARAMETERS_IE );
 133   ACE_OS::memcpy(ie_ptr->IE, &ie_aalparams, sizeof(AAL_PARAMETERS_IE));
 134
 135   ie_ptr = (Q2931_IE *) ((char *)ie_ptr + ie_ptr->IELength);
 136   ie_ptr->IEType = IE_TrafficDescriptor;
 137   ie_ptr->IELength = sizeof( Q2931_IE_TYPE )
 138     + sizeof( ULONG )
 139     + sizeof( ATM_TRAFFIC_DESCRIPTOR_IE );
 140   ACE_OS::memcpy(ie_ptr->IE, &ie_td, sizeof(ATM_TRAFFIC_DESCRIPTOR_IE));
 141
 142   ie_ptr = (Q2931_IE *) ((char *)ie_ptr + ie_ptr->IELength);
 143   ie_ptr->IEType = IE_BroadbandBearerCapability;
 144   ie_ptr->IELength = sizeof( Q2931_IE_TYPE )
 145     + sizeof( ULONG )
 146     + sizeof( ATM_BROADBAND_BEARER_CAPABILITY_IE );
 147   ACE_OS::memcpy(ie_ptr->IE,
 148                  &ie_bbc,
 149                  sizeof(ATM_BROADBAND_BEARER_CAPABILITY_IE));
 150
 151   ie_ptr = (Q2931_IE *) ((char *)ie_ptr + ie_ptr->IELength);
 152   ie_ptr->IEType = IE_QOSClass;
 153   ie_ptr->IELength = sizeof( Q2931_IE_TYPE )
 154     + sizeof( ULONG )
 155     + sizeof( ATM_QOS_CLASS_IE );
 156   ACE_OS::memcpy(ie_ptr->IE, &ie_qos, sizeof(ATM_QOS_CLASS_IE));
 157
 158   //    qos_.SendingFlowspec.TokenRate = 0xffffffff;
 159   //    qos_.SendingFlowspec.TokenBucketSize = 0xffffffff;
 160   //    qos_.SendingFlowspec.PeakBandwidth = 0xffffffff;
 161   //    qos_.SendingFlowspec.Latency = 0xffffffff;
 162   //    qos_.SendingFlowspec.DelayVariation = 0xffffffff;
 163   //    qos_.SendingFlowspec.ServiceType = SERVICETYPE_BESTEFFORT;
 164   // This will most probably be ignored by the service provider.
 165   //    qos_.SendingFlowspec.MaxSduSize = 0xffffffff;
 166   //    qos_.SendingFlowspec.MinimumPolicedSize = 0xffffffff;
 167
 168   //    qos_.ReceivingFlowspec.TokenRate = 0xffffffff;
 169   //    qos_.ReceivingFlowspec.TokenBucketSize = 0xffffffff;
 170   //    qos_.ReceivingFlowspec.PeakBandwidth = 0xffffffff;
 171   //    qos_.ReceivingFlowspec.Latency = 0xffffffff;
 172   //    qos_.ReceivingFlowspec.DelayVariation = 0xffffffff;
 173   //    qos_.ReceivingFlowspec.ServiceType = SERVICETYPE_BESTEFFORT;
 174   // This will most probably be ignored by the service provider.
 175   //    qos_.ReceivingFlowspec.MaxSduSize = 0xffffffff;
 176   //    qos_.ReceivingFlowspec.MinimumPolicedSize = 0;
 177
 178   ACE_Flow_Spec send_fspec( 0xffffffff,
 179                             0xffffffff,
 180                             0xffffffff,
 181                             0xffffffff,
 182                             0xffffffff,
 183                             SERVICETYPE_BESTEFFORT,
 184                             // This will most probably ignored by SP.
 185                             0xffffffff,
 186                             0xffffffff,
 187                             15,
 188                             ACE_DEFAULT_THREAD_PRIORITY ),
 189     recv_fspec( 0xffffffff,
 190                 0xffffffff,
 191                 0xffffffff,
 192                 0xffffffff,
 193                 0xffffffff,
 194                 SERVICETYPE_BESTEFFORT,
 195                 // This will most probably ignored by SP.
 196                 0xffffffff,
 197                 0,
 198                 15,
 199                 ACE_DEFAULT_THREAD_PRIORITY );
 200
 201   qos_.sending_flowspec (send_fspec);
 202   qos_.receiving_flowspec (recv_fspec);
 203 #elif defined (ACE_HAS_FORE_ATM_XTI)
 204   ACE_UNUSED_ARG (rate);
 205   ACE_UNUSED_ARG (pktSize);
 206 #elif defined (ACE_HAS_LINUX_ATM)
 207   ACE_OS::memset(&qos_,
 208                  0,
 209                  sizeof(qos_));
 210   qos_.aal = ATM_PROTOCOL_DEFAULT;
 211   qos_.rxtp.max_sdu = pktSize;
 212
 213   if (rate > 0) {
 214     qos_.rxtp.pcr = rate;
 215     qos_.rxtp.traffic_class = ATM_CBR;
 216     qos_.txtp.traffic_class = ATM_CBR;
 217     qos_.txtp.pcr = rate;
 218   }
 219   else {
 220     qos_.rxtp.traffic_class = ATM_UBR;
 221     qos_.txtp.traffic_class = ATM_UBR;
 222   }
 223
 224   qos_.txtp.max_sdu = pktSize;
 225 #else
 226   ACE_UNUSED_ARG (rate);
 227 #endif /* ACE_HAS_FORE_ATM_WS2 || ACE_HAS_FORE_ATM_XTI || ACE_HAS_LINUX_ATM */
 228 }
 229
 230 void
 231 ACE_ATM_QoS::set_cbr_rate (int rate,
 232                            int pktSize)
 233 {
 234   ACE_TRACE ("ACE_ATM_QoS::set_cbr_rate");
 235 #if defined (ACE_HAS_FORE_ATM_WS2)
 236   /*
 237   AAL_PARAMETERS_IE ie_aalparams;
 238   ATM_TRAFFIC_DESCRIPTOR_IE ie_td;
 239   ATM_BROADBAND_BEARER_CAPABILITY_IE ie_bbc;
 240   ATM_QOS_CLASS_IE ie_qos;
 241   Q2931_IE *ie_ptr;
 242   int size;
 243   */
 244
 245   ACE_OS::printf( "ATM_QoS(set_cbr_rate): set rate to %d c/s\n", rate );
 246
 247   // Setting up cbr parameters ...
 248   /*
 249   FORE has changed this - we no longer specify QoS this way
 250   ie_aalparams.AALType = AALTYPE_5;
 251   ie_aalparams.AALSpecificParameters.AAL5Parameters.ForwardMaxCPCSSDUSize
 252     = pktSize; // was 1516;
 253   ie_aalparams.AALSpecificParameters.AAL5Parameters.BackwardMaxCPCSSDUSize
 254     = pktSize; // was 1516;
 255   ie_aalparams.AALSpecificParameters.AAL5Parameters.Mode = AAL5_MODE_MESSAGE;
 256   ie_aalparams.AALSpecificParameters.AAL5Parameters.SSCSType = AAL5_SSCS_NULL;
 257
 258   size = sizeof(Q2931_IE_TYPE) + sizeof(ULONG) + sizeof(AAL_PARAMETERS_IE);
 259
 260   ie_td.Forward.PeakCellRate_CLP0 = SAP_FIELD_ABSENT;
 261   ie_td.Forward.PeakCellRate_CLP01 = rate;
 262   ie_td.Forward.SustainableCellRate_CLP0 = SAP_FIELD_ABSENT;
 263   ie_td.Forward.SustainableCellRate_CLP01 = SAP_FIELD_ABSENT;
 264   ie_td.Forward.MaxBurstSize_CLP0 = SAP_FIELD_ABSENT;
 265   ie_td.Forward.MaxBurstSize_CLP01 = SAP_FIELD_ABSENT;
 266   ie_td.Forward.Tagging = SAP_FIELD_ABSENT;
 267
 268   ie_td.Backward.PeakCellRate_CLP0 = SAP_FIELD_ABSENT;
 269   ie_td.Backward.PeakCellRate_CLP01 = rate;
 270   ie_td.Backward.SustainableCellRate_CLP0 = SAP_FIELD_ABSENT;
 271   ie_td.Backward.SustainableCellRate_CLP01 = SAP_FIELD_ABSENT;
 272   ie_td.Backward.MaxBurstSize_CLP0 = SAP_FIELD_ABSENT;
 273   ie_td.Backward.MaxBurstSize_CLP01 = SAP_FIELD_ABSENT;
 274   ie_td.Backward.Tagging = SAP_FIELD_ABSENT;
 275
 276   ie_td.BestEffort = 0; // Note: this must be set to zero for CBR.
 277
 278   size += sizeof( Q2931_IE_TYPE ) +
 279           sizeof( ULONG ) +
 280           sizeof( ATM_TRAFFIC_DESCRIPTOR_IE );
 281
 282   ie_bbc.BearerClass = BCOB_X;
 283   ie_bbc.TrafficType = TT_CBR;
 284   ie_bbc.TimingRequirements = TR_END_TO_END;
 285   ie_bbc.ClippingSusceptability = CLIP_NOT;
 286   ie_bbc.UserPlaneConnectionConfig = UP_P2P;
 287
 288   size += sizeof(Q2931_IE_TYPE) +
 289           sizeof(ULONG) +
 290           sizeof(ATM_BROADBAND_BEARER_CAPABILITY_IE);
 291
 292   ie_qos.QOSClassForward = QOS_CLASS1;
 293   ie_qos.QOSClassBackward = QOS_CLASS1; // This may not be really used
 294   // since we only simplex data xfer.
 295
 296   size += sizeof(Q2931_IE_TYPE) + sizeof(ULONG) + sizeof(ATM_QOS_CLASS_IE);
 297
 298   qos_.ProviderSpecific.buf = (char *) ACE_OS::malloc(size);
 299   if (qos_.ProviderSpecific.buf == 0) {
 300     ACE_ERROR((LM_ERROR,
 301                ACE_TEXT ("ACE_ATM_QoS::ACE_ATM_QoS: Unable to allocate %d bytes for qos_.ProviderSpecific.buf\n"),
 302                size));
 303     return;
 304   }
 305   qos_.ProviderSpecific.len = size;
 306   ACE_OS::memset(qos_.ProviderSpecific.buf, 0, size);
 307
 308   ie_ptr = (Q2931_IE *) qos_.ProviderSpecific.buf;
 309   ie_ptr->IEType = IE_AALParameters;
 310   ie_ptr->IELength = sizeof( Q2931_IE_TYPE ) +
 311                      sizeof( ULONG ) +
 312                      sizeof( AAL_PARAMETERS_IE );
 313   ACE_OS::memcpy(ie_ptr->IE, &ie_aalparams, sizeof(AAL_PARAMETERS_IE));
 314
 315   ie_ptr = (Q2931_IE *) ((char *)ie_ptr + ie_ptr->IELength);
 316   ie_ptr->IEType = IE_TrafficDescriptor;
 317   ie_ptr->IELength = sizeof( Q2931_IE_TYPE ) +
 318                      sizeof( ULONG ) +
 319                      sizeof( ATM_TRAFFIC_DESCRIPTOR_IE );
 320   ACE_OS::memcpy(ie_ptr->IE, &ie_td, sizeof(ATM_TRAFFIC_DESCRIPTOR_IE));
 321
 322   ie_ptr = (Q2931_IE *) ((char *)ie_ptr + ie_ptr->IELength);
 323   ie_ptr->IEType = IE_BroadbandBearerCapability;
 324   ie_ptr->IELength = sizeof( Q2931_IE_TYPE ) +
 325                      sizeof( ULONG ) +
 326                      sizeof( ATM_BROADBAND_BEARER_CAPABILITY_IE );
 327   ACE_OS::memcpy( ie_ptr->IE,
 328                   &ie_bbc,
 329                   sizeof( ATM_BROADBAND_BEARER_CAPABILITY_IE ));
 330
 331   ie_ptr = (Q2931_IE *) ((char *)ie_ptr + ie_ptr->IELength);
 332   ie_ptr->IEType = IE_QOSClass;
 333   ie_ptr->IELength = sizeof(Q2931_IE_TYPE) + sizeof(ULONG) +
 334                      sizeof(ATM_QOS_CLASS_IE);
 335   ACE_OS::memcpy(ie_ptr->IE, &ie_qos, sizeof(ATM_QOS_CLASS_IE));
 336   */
 337
 338   const int BYTES_PER_ATM_CELL = 53;
 339   ACE_OS::memset(&qos_, 0, sizeof(ATM_QoS));
 340   // Setting the token rate sets the minimum rate. 3 Mbits/sec seems too high.
 341   //  Certainly for Vaudeville audio, we only need about 1000 c/s which is
 342   //  424000 bits/sec which is 53000 bytes/sec.
 343   //qos_.SendingFlowspec.TokenRate = 3*(1024*128);      // 3Mbits/sec
 344   qos_.SendingFlowspec.TokenRate = 53000;               // 1000 cells/sec
 345   qos_.SendingFlowspec.TokenBucketSize = 32*1024;       // our block size
 346   //ourQos.SendingFlowspec.PeakBandwidth = ourQos.SendingFlowspec.TokenRate;
 347   qos_.SendingFlowspec.ServiceType = SERVICETYPE_GUARANTEED;
 348   // Peak bandwidth is in bytes/sec. The rate is specified in cells/sec so
 349   //  we need to convert from cells/sec to bytes/sec (i.e., multiply by 53).
 350   qos_.SendingFlowspec.PeakBandwidth = rate * BYTES_PER_ATM_CELL;
 351   qos_.SendingFlowspec.Latency = -1;    // we don't care too much
 352   qos_.SendingFlowspec.DelayVariation = -1; // we don't care too much
 353   // no provider-specific data allowed on ATM
 354   qos_.ProviderSpecific.buf=0;
 355   qos_.ProviderSpecific.len=0;
 356   // unidirectional P2MP; we don't need to setup the Receiving flowspec
 357
 358   //qos_.SendingFlowspec.TokenRate = 0xffffffff;
 359   //qos_.SendingFlowspec.TokenBucketSize = 0xffffffff;
 360   //qos_.SendingFlowspec.PeakBandwidth = 0xffffffff;
 361   //qos_.SendingFlowspec.Latency = 0xffffffff;
 362   //qos_.SendingFlowspec.DelayVariation = 0xffffffff;
 363   //qos_.SendingFlowspec.ServiceType = SERVICETYPE_BESTEFFORT;
 364   // This will most probably be ignored by the service provider.
 365   //qos_.SendingFlowspec.MaxSduSize = 0xffffffff;
 366   //qos_.SendingFlowspec.MinimumPolicedSize = 0xffffffff;
 367
 368   //qos_.ReceivingFlowspec.TokenRate = 0xffffffff;
 369   //qos_.ReceivingFlowspec.TokenBucketSize = 0xffffffff;
 370   //qos_.ReceivingFlowspec.PeakBandwidth = 0xffffffff;
 371   //qos_.ReceivingFlowspec.Latency = 0xffffffff;
 372   //qos_.ReceivingFlowspec.DelayVariation = 0xffffffff;
 373   //qos_.ReceivingFlowspec.ServiceType = SERVICETYPE_BESTEFFORT;
 374   // This will most probably be ignored by the service provider.
 375   //qos_.ReceivingFlowspec.MaxSduSize = 0xffffffff;
 376   //qos_.ReceivingFlowspec.MinimumPolicedSize = 0;
 377
 378   /*
 379   ACE_Flow_Spec send_fspec( 0xffffffff,
 380                             0xffffffff,
 381                             0xffffffff,
 382                             0xffffffff,
 383                             0xffffffff,
 384                             SERVICETYPE_BESTEFFORT,
 385                             // This will most probably ignored by SP.
 386                             0xffffffff,
 387                             0xffffffff,
 388                             15,
 389                             ACE_DEFAULT_THREAD_PRIORITY ),
 390   recv_fspec( 0xffffffff,
 391               0xffffffff,
 392               0xffffffff,
 393               0xffffffff,
 394               0xffffffff,
 395               SERVICETYPE_BESTEFFORT,
 396               // This will most probably ignored by SP.
 397               0xffffffff,
 398               0,
 399               15,
 400               ACE_DEFAULT_THREAD_PRIORITY );
 401
 402   qos_.sending_flowspec( send_fspec );
 403   qos_.receiving_flowspec( recv_fspec );
 404   */
 405 #elif defined (ACE_HAS_FORE_ATM_XTI)
 406   ACE_UNUSED_ARG (rate);
 407   ACE_UNUSED_ARG (pktSize);
 408 #elif defined (ACE_HAS_LINUX_ATM)
 409   ACE_UNUSED_ARG (pktSize);
 410
 411   qos_.rxtp.traffic_class = ATM_CBR;
 412   qos_.rxtp.pcr = rate;
 413   qos_.txtp.traffic_class = ATM_CBR;
 414   qos_.txtp.pcr = rate;
 415 #else
 416   ACE_UNUSED_ARG (rate);
 417 #endif /* ACE_HAS_FORE_ATM_WS2 || ACE_HAS_FORE_ATM_XTI || ACE_HAS_LINUX_ATM */
 418 }
 419
 420 void
 421 ACE_ATM_QoS::set_rate (ACE_HANDLE fd,
 422                        int rate,
 423                        int flags)
 424 {
 425   ACE_TRACE ("ACE_ATM_QoS::set_rate");
 426 #if defined (ACE_HAS_FORE_ATM_WS2) || defined (ACE_HAS_LINUX_ATM)
 427   set_cbr_rate( rate );
 428
 429   ACE_UNUSED_ARG( fd );
 430   ACE_UNUSED_ARG( flags );
 431 #elif defined (ACE_HAS_FORE_ATM_XTI)
 432   long optlen = 0;
 433   qos_.buf = construct_options(fd,
 434                                rate,
 435                                flags,
 436                                &optlen);
 437   qos_.len = optlen;
 438 #else
 439   ACE_UNUSED_ARG (rate);
 440 #endif /* ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM || ACE_HAS_FORE_ATM_XTI */
 441 }
 442
 443 char*
 444 ACE_ATM_QoS::construct_options (ACE_HANDLE fd,
 445                                 int rate,
 446                                 int flags,
 447                                 long *len)
 448 {
 449 #if defined (ACE_HAS_FORE_ATM_WS2) || defined (ACE_HAS_LINUX_ATM)
 450   ACE_UNUSED_ARG (fd);
 451   ACE_UNUSED_ARG (rate);
 452   ACE_UNUSED_ARG (flags);
 453   ACE_UNUSED_ARG (len);
 454   return (0);
 455 #elif defined (ACE_HAS_FORE_ATM_XTI)
 456   struct t_opthdr *popt;
 457   char *buf;
 458   int qos_cells;
 459   struct t_info info;
 460
 461   if (ACE_OS::t_getinfo (fd, &info) == -1)
 462     {
 463       ACE_OS::t_error ("t_getinfo");
 464       return 0;
 465     }
 466
 467   buf = (char *) ACE_OS::malloc (info.options);
 468
 469   if (buf == 0)
 470     ACE_ERROR_RETURN ((LM_ERROR,
 471                        ACE_TEXT ("Unable to allocate %d bytes for options\n"),
 472                        info.options),
 473                       0);
 474
 475   popt = (struct t_opthdr *) buf;
 476
 477   if (flags & OPT_FLAGS_CPID)
 478     {
 479       // This constructs the T_ATM_ORIG_ADDR option, which is used to
 480       // signal the UNI 3.1 Calling Party ID Information Element.
 481       t_atm_addr *source_addr;
 482
 483       popt->len = sizeof (struct t_opthdr) + sizeof (t_atm_addr);
 484       popt->level = T_ATM_SIGNALING;
 485       popt->name = T_ATM_ORIG_ADDR;
 486       popt->status = 0;
 487
 488       source_addr =
 489         (t_atm_addr *)((char *) popt + sizeof (struct t_opthdr));
 490
 491       source_addr->address_format = T_ATM_ENDSYS_ADDR;
 492       source_addr->address_length = ATMNSAP_ADDR_LEN;
 493
 494       ATMSAPAddress local_addr;
 495       struct t_bind boundaddr;
 496
 497       boundaddr.addr.maxlen = sizeof(local_addr);
 498       boundaddr.addr.buf = (char *) &local_addr;
 499
 500       //if (ACE_OS::t_getprotaddr(fd, &boundaddr, 0) < 0) {
 501       if (ACE_OS::t_getname(fd,
 502                             &boundaddr.addr,
 503                             LOCALNAME) < 0)
 504         {
 505           ACE_OS::t_error("t_getname (local_address)");
 506           ACE_ERROR ((LM_ERROR,
 507                       ACE_TEXT ("Can't get local address!\n")));
 508           ACE_OS::free (buf);
 509           return 0;
 510         }
 511
 512       ACE_OS::memcpy(source_addr->address,
 513                      local_addr.sap.t_atm_sap_addr.address,
 514                      ATMNSAP_ADDR_LEN);
 515
 516       popt = T_OPT_NEXTHDR (buf, info.options , popt);
 517     }
 518
 519   // This constructs all options necessary (bearer cap., QoS, and
 520   // Traffic Descriptor) to signal for a CBR connection with the
 521   // specified QoS in kbit/sec., and/or specify a PMP connection.
 522
 523   // For FORE 200e cards, the adapter shapes traffic to CBR with rate
 524   // equal to PCR CLP=0+1 (traffic.forward.PCR_all_traffic)
 525
 526   qos_cells = (rate * 1000) / (48*8);
 527
 528   if ((qos_cells > 0 && qos_cells < LINE_RATE)
 529       || (ACE_BIT_ENABLED (flags, OPT_FLAGS_PMP)))
 530     {
 531       struct t_atm_bearer *bearer;
 532       struct t_atm_traffic *traffic;
 533
 534       // T_ATM_BEARER_CAP: Broadband bearer capability
 535       popt->len = sizeof (struct t_opthdr) + sizeof (struct t_atm_bearer);
 536       popt->level = T_ATM_SIGNALING;
 537       popt->name = T_ATM_BEARER_CAP;
 538       popt->status = 0;
 539
 540       bearer = (struct t_atm_bearer *)((char *) popt +
 541                                        sizeof (struct t_opthdr));
 542       bearer->bearer_class = T_ATM_CLASS_X;
 543
 544       if (qos_cells)
 545         {
 546           bearer->traffic_type = T_ATM_CBR;
 547           bearer->timing_requirements = T_ATM_END_TO_END;
 548         }
 549       else
 550         {
 551           bearer->traffic_type   = 0; // UBR
 552           bearer->timing_requirements = 0;
 553         }
 554       bearer->clipping_susceptibility = T_ATM_NULL;
 555
 556       if (ACE_BIT_ENABLED (flags, OPT_FLAGS_PMP))
 557         bearer->connection_configuration = T_ATM_1_TO_MANY;
 558       else
 559         bearer->connection_configuration = T_ATM_1_TO_1;
 560
 561       popt = T_OPT_NEXTHDR (buf, info.options, popt);
 562
 563       // T_ATM_TRAFFIC: traffic descriptor
 564       popt->len = sizeof (struct t_opthdr) + sizeof (struct t_atm_traffic);
 565       popt->level = T_ATM_SIGNALING;
 566       popt->name = T_ATM_TRAFFIC;
 567       popt->status = 0;
 568
 569       traffic = (struct t_atm_traffic *)((char *) popt +
 570                                          sizeof (struct t_opthdr));
 571
 572       traffic->forward.PCR_high_priority = T_ATM_ABSENT;
 573       traffic->forward.PCR_all_traffic = qos_cells ? qos_cells : LINE_RATE;
 574       traffic->forward.SCR_high_priority = T_ATM_ABSENT;
 575       traffic->forward.SCR_all_traffic = T_ATM_ABSENT;
 576       traffic->forward.MBS_high_priority = T_ATM_ABSENT;
 577       traffic->forward.MBS_all_traffic = T_ATM_ABSENT;
 578       traffic->forward.tagging = T_NO;
 579
 580       traffic->backward.PCR_high_priority = T_ATM_ABSENT;
 581       traffic->backward.PCR_all_traffic =
 582         (ACE_BIT_ENABLED (flags, OPT_FLAGS_PMP))
 583         ? 0 : qos_cells ? qos_cells : LINE_RATE;
 584       traffic->backward.SCR_high_priority = T_ATM_ABSENT;
 585       traffic->backward.SCR_all_traffic = T_ATM_ABSENT;
 586       traffic->backward.MBS_high_priority = T_ATM_ABSENT;
 587       traffic->backward.MBS_all_traffic = T_ATM_ABSENT;
 588       traffic->backward.tagging = T_NO;
 589
 590       traffic->best_effort = qos_cells ? T_NO : T_YES;
 591
 592       popt = T_OPT_NEXTHDR (buf,
 593                             info.options,
 594                             popt);
 595     }
 596
 597   if (qos_cells > 0 && qos_cells < LINE_RATE)
 598     {
 599       struct t_atm_qos *qos;
 600
 601       // T_ATM_QOS: Quality of Service
 602       popt->len = sizeof (struct t_opthdr) + sizeof (struct t_atm_qos);
 603       popt->level = T_ATM_SIGNALING;
 604       popt->name = T_ATM_QOS;
 605       popt->status = 0;
 606
 607       qos = (struct t_atm_qos *)((char *) popt + sizeof (struct t_opthdr));
 608       qos->coding_standard = T_ATM_ITU_CODING;
 609       qos->forward.qos_class = T_ATM_QOS_CLASS_1;
 610       qos->backward.qos_class = T_ATM_QOS_CLASS_1;
 611
 612       popt = T_OPT_NEXTHDR (buf, info.options, popt);
 613     }
 614
 615   // Return actual size of options and option buffer to user.
 616   *len = (char *) popt - buf;
 617
 618   return buf;
 619 #else
 620   ACE_UNUSED_ARG (fd);
 621   ACE_UNUSED_ARG (rate);
 622   ACE_UNUSED_ARG (flag);
 623   ACE_UNUSED_ARG (len);
 624   return (0);
 625 #endif /* ACE_HAS_FORE_ATM_WS2 */
 626 }
 627
 628 ACE_END_VERSIONED_NAMESPACE_DECL
 629
 630 #endif /* ACE_HAS_ATM */
 631