orte/liborte/parameter.c

   1 /*
   2  *  $Id: parameter.c,v 0.0.0.1          2003/10/13
   3  *
   4  *  DEBUG:  section 11                  parameter
   5  *
   6  *  -------------------------------------------------------------------
   7  *                                ORTE
   8  *                      Open Real-Time Ethernet
   9  *
  10  *                      Copyright (C) 2001-2006
  11  *  Department of Control Engineering FEE CTU Prague, Czech Republic
  12  *                      http://dce.felk.cvut.cz
  13  *                      http://www.ocera.org
  14  *
  15  *  Author:              Petr Smolik    petr@smoliku.cz
  16  *  Advisor:             Pavel Pisa
  17  *  Project Responsible: Zdenek Hanzalek
  18  *  --------------------------------------------------------------------
  19  *
  20  *  This program is free software; you can redistribute it and/or modify
  21  *  it under the terms of the GNU General Public License as published by
  22  *  the Free Software Foundation; either version 2 of the License, or
  23  *  (at your option) any later version.
  24  *
  25  *  This program is distributed in the hope that it will be useful,
  26  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  27  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28  *  GNU General Public License for more details.
  29  *
  30  */
  31
  32 #include "orte_all.h"
  33
  34 /*****************************************************************************/
  35 void
  36 parameterPutString(ParameterSequence *ps, int8_t id, int8_t *sstr)
  37 {
  38   int               len;
  39
  40   len = strlen((char *)sstr)+1;
  41   ps->parameterID = id;
  42   ps->parameterLength = len;
  43   ps->parameter = NULL;
  44
  45   if (MAX_PARAMETER_LOCAL_LENGTH < len) {
  46     ps->parameter = (u_char *)MALLOC(len);
  47     strncpy((char *)ps->parameter, (const char *)sstr, len);
  48   } else {
  49     strncpy((char *)ps->parameterLocal.asStr, (const char *)sstr, len);
  50   }
  51 }
  52
  53 /*****************************************************************************/
  54 int
  55 parameterDelete(CSChange *csChange)
  56 {
  57   ParameterSequence *ps;
  58
  59   ul_list_for_each(CSChangeAttributes,
  60                    csChange,
  61                    ps) {
  62     if ((ps->parameterLength) > MAX_PARAMETER_LOCAL_LENGTH)
  63       FREE(ps->parameter);
  64   }
  65   //ps is like one piece of memory
  66   if (CSChangeAttributes_first(csChange))
  67     FREE(CSChangeAttributes_first(csChange));
  68   CSChangeAttributes_init_head(csChange);
  69   return ORTE_TRUE;
  70 }
  71
  72
  73 /*****************************************************************************/
  74 int
  75 parameterCodeCodecFromCSChange(CSChange *csChange, CDR_Codec *cdrCodec)
  76 {
  77   ParameterSequence *ps;
  78
  79   ul_list_for_each(CSChangeAttributes,
  80                    csChange,
  81                    ps) {
  82
  83     if (CDR_put_ushort(cdrCodec, ps->parameterID) == CORBA_FALSE)
  84       return -1;
  85     if (CDR_put_ushort(cdrCodec, ps->parameterLength) == CORBA_FALSE)
  86       return -1;
  87
  88     debug(11, 10) ("parameterCodeCodecToCSChange: parameterID-0x%x, len-%d\n",
  89                    ps->parameterID, ps->parameterLength);
  90
  91     switch (ps->parameterID) {
  92       case PID_SENTINEL:
  93         break;
  94       //NtpTime
  95       case PID_EXPIRATION_TIME:
  96       case PID_PERSISTENCE:
  97       case PID_MINIMUM_SEPARATION:
  98         /* time in seconds */
  99         if (CDR_put_long(cdrCodec, ps->parameterLocal.asNtpTime.seconds) ==
 100             CORBA_FALSE)
 101           return -1;
 102         /* time in seconds / 2^32 */
 103         if (CDR_put_ulong(cdrCodec, ps->parameterLocal.asNtpTime.fraction) ==
 104             CORBA_FALSE)
 105           return -1;
 106         break;
 107       //CORBA_unsigned_long
 108       case PID_TYPE_CHECKSUM:
 109       case PID_STRENGTH:
 110       case PID_SEND_QUEUE_SIZE:
 111       case PID_RECV_QUEUE_SIZE:
 112       case PID_RELIABILITY_OFFERED:
 113       case PID_RELIABILITY_REQUESTED:
 114       case PID_MANAGER_KEY:
 115       case PID_MATATRAFFIC_MULTICAST_IPADDRESS:
 116       case PID_APP_IPADDRESS:
 117       case PID_USERDATA_MULTICAST_IPADDRESS:
 118       case PID_METATRAFFIC_UNICAST_PORT:
 119       case PID_USERDATA_UNICAST_PORT:
 120         if (CDR_put_ulong(cdrCodec, ps->parameterLocal.asLong) ==
 121             CORBA_FALSE)
 122           return -1;
 123         break;
 124       //VendorId
 125       case PID_VENDOR_ID:
 126         if (CDR_put_octet(cdrCodec, ps->parameterLocal.asVendorId.major) ==
 127             CORBA_FALSE)
 128           return -1;
 129         if (CDR_put_octet(cdrCodec, ps->parameterLocal.asVendorId.minor) ==
 130             CORBA_FALSE)
 131           return -1;
 132         break;
 133       //ProtocolVersion
 134       case PID_PROTOCOL_VERSION:
 135         if (CDR_put_octet(cdrCodec, ps->parameterLocal.asProtocolVersion.major) ==
 136             CORBA_FALSE)
 137           return -1;
 138         if (CDR_put_octet(cdrCodec, ps->parameterLocal.asProtocolVersion.minor) ==
 139             CORBA_FALSE)
 140           return -1;
 141         break;
 142       //SequenceNumber
 143       case PID_VARGAPPS_SEQUENCE_NUMBER_LAST:
 144         if (CDR_put_ulong(cdrCodec, ps->parameterLocal.asSequenceNumber.high) ==
 145             CORBA_FALSE)
 146           return -1;
 147         if (CDR_put_ulong(cdrCodec, ps->parameterLocal.asSequenceNumber.low) ==
 148             CORBA_FALSE)
 149           return -1;
 150         break;
 151       //Boolean
 152       case PID_EXPECTS_ACK:
 153         if (CDR_put_octet(cdrCodec, ps->parameterLocal.asOctet) ==
 154             CORBA_FALSE)
 155           return -1;
 156         break;
 157       //PathName,TypeName
 158       case PID_TOPIC:
 159       case PID_TYPE_NAME: {
 160         int wptr, len;
 161
 162         wptr = cdrCodec->wptr;
 163
 164         len = ps->parameterLength;
 165         if (len % 4) {                    //length alignment to 4
 166           len &= ~3;
 167           len += 4;
 168         }
 169         len += 4;                           //data size
 170         cdrCodec->wptr -= 2;                //new alignments value
 171         if (CDR_put_ushort(cdrCodec, (CORBA_unsigned_short)len) == CORBA_FALSE)
 172           return -1;
 173
 174         if (ps->parameterLength > MAX_PARAMETER_LOCAL_LENGTH) {
 175           if (CDR_put_string(cdrCodec, (char *)ps->parameter) ==
 176               CORBA_FALSE)
 177             return -1;
 178         } else {
 179           if (CDR_put_string(cdrCodec, (char *)ps->parameterLocal.asStr) ==
 180               CORBA_FALSE)
 181             return -1;
 182         }
 183
 184         cdrCodec->wptr = wptr+len;
 185       } break;
 186       case PID_PAD:
 187         break;
 188       default:
 189         debug(11, 1) ("parameterCodeCodecFromCSChange: undefined parameterID: %d\n",
 190                       ps->parameterID);
 191         break;
 192     }
 193   }
 194   return 0;
 195 }
 196
 197 /*****************************************************************************/
 198 int
 199 parameterDecodeCodecToCSChange(CSChange *csChange, CDR_Codec *cdrCodec)
 200 {
 201   ParameterId       parameterId;
 202   ParameterLength   parameterLength;
 203   ParameterSequence *ps;
 204   uint16_t          counter = 0;
 205   unsigned int      rptr;
 206
 207   CSChangeAttributes_init_head(csChange);
 208   rptr = cdrCodec->rptr;
 209
 210   //count number of parameters -> we need one memory allocation for ps
 211   while (cdrCodec->rptr < cdrCodec->buf_len) {
 212     if (CDR_get_ushort(cdrCodec, &parameterId) == CORBA_FALSE)
 213       break;
 214     if (CDR_get_ushort(cdrCodec, &parameterLength) == CORBA_FALSE)
 215       break;
 216     if (parameterId == PID_SENTINEL)
 217       break;
 218     counter++;
 219     cdrCodec->rptr += parameterLength;
 220   }
 221
 222   ps = (ParameterSequence *)MALLOC(sizeof(ParameterSequence)*(counter+1));
 223   cdrCodec->rptr = rptr;
 224
 225   while (counter) {
 226     CDR_get_ushort(cdrCodec, &parameterId);
 227     CDR_get_ushort(cdrCodec, &parameterLength);
 228
 229     ps->parameterID = parameterId;
 230     ps->parameterLength = parameterLength;
 231     ps->parameter = NULL;
 232
 233     /* save start position of parameter */
 234     rptr = cdrCodec->rptr;
 235
 236     debug(11, 10) ("parameterDecodeCodecToCSChange: parameterID-0x%x, len-%d\n",
 237                    parameterId, parameterLength);
 238     switch (parameterId) {
 239       case PID_SENTINEL:
 240         counter = 1;
 241         break;
 242       //NtpTime
 243       case PID_EXPIRATION_TIME:
 244       case PID_PERSISTENCE:
 245       case PID_MINIMUM_SEPARATION:
 246         /* time in seconds */
 247         CDR_get_long(cdrCodec, &ps->parameterLocal.asNtpTime.seconds);
 248         /* time in seconds / 2^32 */
 249         CDR_get_ulong(cdrCodec, (CORBA_unsigned_long *)&ps->parameterLocal.asNtpTime.fraction);
 250         break;
 251       //CORBA_unsigned_long
 252       case PID_TYPE_CHECKSUM:
 253       case PID_STRENGTH:
 254       case PID_SEND_QUEUE_SIZE:
 255       case PID_RECV_QUEUE_SIZE:
 256       case PID_RELIABILITY_OFFERED:
 257       case PID_RELIABILITY_REQUESTED:
 258       case PID_MANAGER_KEY:
 259       case PID_MATATRAFFIC_MULTICAST_IPADDRESS:
 260       case PID_APP_IPADDRESS:
 261       case PID_USERDATA_MULTICAST_IPADDRESS:
 262       case PID_METATRAFFIC_UNICAST_PORT:
 263       case PID_USERDATA_UNICAST_PORT:
 264         CDR_get_ulong(cdrCodec, &ps->parameterLocal.asLong);
 265         break;
 266       //VendorId
 267       case PID_VENDOR_ID:
 268         CDR_get_octet(cdrCodec, (CORBA_octet *)&ps->parameterLocal.asVendorId.major);
 269         CDR_get_octet(cdrCodec, (CORBA_octet *)&ps->parameterLocal.asVendorId.minor);
 270         break;
 271       //ProtocolVersion
 272       case PID_PROTOCOL_VERSION:
 273         CDR_get_octet(cdrCodec, (CORBA_octet *)&ps->parameterLocal.asProtocolVersion.major);
 274         CDR_get_octet(cdrCodec, (CORBA_octet *)&ps->parameterLocal.asProtocolVersion.minor);
 275         break;
 276       //SequenceNumber
 277       case PID_VARGAPPS_SEQUENCE_NUMBER_LAST:
 278         CDR_get_ulong(cdrCodec, (CORBA_unsigned_long *)&ps->parameterLocal.asSequenceNumber.high);
 279         CDR_get_ulong(cdrCodec, (CORBA_unsigned_long *)&ps->parameterLocal.asSequenceNumber.low);
 280         break;
 281       //Boolean
 282       case PID_EXPECTS_ACK:
 283         CDR_get_octet(cdrCodec, ps->parameterLocal.asStr);
 284         break;
 285       //PathName,TypeName
 286       case PID_TOPIC:
 287       case PID_TYPE_NAME: {
 288         CORBA_unsigned_long len;
 289
 290         CDR_get_ulong(cdrCodec, (CORBA_unsigned_long *)&len);
 291         cdrCodec->rptr -= 4;
 292         ps->parameterLength = (uint16_t)len;
 293         if (ps->parameterLength > MAX_PARAMETER_LOCAL_LENGTH) {
 294           CDR_get_string(cdrCodec, (CORBA_char **)&ps->parameter);
 295         } else {
 296           CDR_get_string_buff(cdrCodec, (CORBA_char *)ps->parameterLocal.asStr);
 297         }
 298       } break;
 299       case PID_PAD:
 300         break;
 301       default:
 302         debug(11, 1) ("parameterDecodeCodecToCSChange: undefined parameterID: %d\n",
 303                       parameterId);
 304         break;
 305     }
 306     CSChangeAttributes_insert(csChange, ps);
 307     ps++; //next ps
 308     counter--;
 309
 310     cdrCodec->rptr = rptr+parameterLength;
 311   }
 312   //SENTINEL
 313   ps->parameterID = PID_SENTINEL;
 314   ps->parameterLength = 0;
 315   ps->parameter = NULL;
 316   CSChangeAttributes_insert(csChange, ps);
 317   return ORTE_TRUE;
 318 }
 319
 320 /*****************************************************************************/
 321 int
 322 parameterUpdateCSChange(
 323   CSChange *csChange, AppParams *ap, Boolean Manager)
 324 {
 325   ParameterSequence *ps;
 326   int               i;
 327
 328   i = ap->managerKeyCount+
 329       ap->metatrafficMulticastIPAddressCount+
 330       ap->unicastIPAddressCount+7;
 331   if (!Manager)
 332     i--;
 333   CSChangeAttributes_init_head(csChange);
 334   ps = (ParameterSequence *)MALLOC(sizeof(ParameterSequence)*i);
 335   //EXPIRATION_TIME
 336   ps->parameterID = PID_EXPIRATION_TIME;
 337   ps->parameterLength = 8;
 338   memcpy(ps->parameterLocal.asStr, &ap->expirationTime, ps->parameterLength);
 339   ps->parameter = NULL;
 340   CSChangeAttributes_insert(csChange, ps);
 341   ps++;
 342   //MATATRAFFIC_MULTICAST_IPADDRESS
 343   for (i = 0; i < ap->metatrafficMulticastIPAddressCount; i++) {
 344     ps->parameterID = PID_MATATRAFFIC_MULTICAST_IPADDRESS;
 345     ps->parameterLength = 4;
 346     ps->parameterLocal.asIPAddress = ap->metatrafficMulticastIPAddressList[i];
 347     ps->parameter = NULL;
 348     CSChangeAttributes_insert(csChange, ps);
 349     ps++;
 350   }
 351   //METATRAFFIC_UNICAST_PORT
 352   ps->parameterID = PID_METATRAFFIC_UNICAST_PORT;
 353   ps->parameterLength = 4;
 354   ps->parameterLocal.asPort = ap->metatrafficUnicastPort;
 355   ps->parameter = NULL;
 356   CSChangeAttributes_insert(csChange, ps);
 357   ps++;
 358   //USERDATA_UNICAST_PORT
 359   ps->parameterID = PID_USERDATA_UNICAST_PORT;
 360   ps->parameterLength = 4;
 361   ps->parameterLocal.asPort = ap->userdataUnicastPort;
 362   ps->parameter = NULL;
 363   CSChangeAttributes_insert(csChange, ps);
 364   ps++;
 365   //APP_IPADDRESS
 366   for (i = 0; i < ap->unicastIPAddressCount; i++) {
 367     ps->parameterID = PID_APP_IPADDRESS;
 368     ;
 369     ps->parameterLength = 4;
 370     ps->parameterLocal.asIPAddress = ap->unicastIPAddressList[i];
 371     ps->parameter = NULL;
 372     CSChangeAttributes_insert(csChange, ps);
 373     ps++;
 374   }
 375   //PROTOCOL_VERSION
 376   ps->parameterID = PID_PROTOCOL_VERSION;
 377   ps->parameterLength = 2;
 378   ps->parameterLocal.asProtocolVersion = ap->protocolVersion;
 379   ps->parameter = NULL;
 380   CSChangeAttributes_insert(csChange, ps);
 381   ps++;
 382   //VENDOR_ID
 383   ps->parameterID = PID_VENDOR_ID;
 384   ps->parameterLength = 2;
 385   ps->parameterLocal.asVendorId = ap->vendorId;
 386   ps->parameter = NULL;
 387   CSChangeAttributes_insert(csChange, ps);
 388   ps++;
 389   if (Manager) {    //Manager
 390     //VARGAPPS_SEQUENCE_NUMBER_LAST
 391     ps->parameterID = PID_VARGAPPS_SEQUENCE_NUMBER_LAST;
 392     ps->parameterLength = 8;
 393     ps->parameterLocal.asSequenceNumber = ap->vargAppsSequenceNumber;
 394     ps->parameter = NULL;
 395     CSChangeAttributes_insert(csChange, ps);
 396     ps++;
 397   }
 398   //MANAGER_KEY
 399   for (i = 0; i < ap->managerKeyCount; i++) {
 400     ps->parameterID = PID_MANAGER_KEY;
 401     ps->parameterLength = 4;
 402     ps->parameterLocal.asUInt32 = ap->managerKeyList[i];
 403     ps->parameter = NULL;
 404     CSChangeAttributes_insert(csChange, ps);
 405     ps++;
 406   }
 407   //SENTINEL
 408   ps->parameterID = PID_SENTINEL;
 409   ps->parameterLength = 0;
 410   ps->parameter = NULL;
 411   CSChangeAttributes_insert(csChange, ps);
 412   return 0;
 413 }
 414
 415 /*****************************************************************************/
 416 int
 417 parameterUpdateCSChangeFromPublication(CSChange *csChange, ORTEPublProp *pp)
 418 {
 419   ParameterSequence *ps;
 420
 421   CSChangeAttributes_init_head(csChange);
 422   ps = (ParameterSequence *)MALLOC(sizeof(ParameterSequence)*8);
 423   //persistence
 424   ps->parameterID = PID_PERSISTENCE;
 425   ps->parameterLength = 8;
 426   memcpy(ps->parameterLocal.asStr, &pp->persistence, ps->parameterLength);
 427   ps->parameter = NULL;
 428   CSChangeAttributes_insert(csChange, ps);
 429   ps++;
 430   /* reliabitityOffered */
 431   ps->parameterID = PID_RELIABILITY_OFFERED;
 432   ps->parameterLength = 4;
 433   ps->parameterLocal.asUInt32 = pp->reliabilityOffered;
 434   ps->parameter = NULL;
 435   CSChangeAttributes_insert(csChange, ps);
 436   ps++;
 437   /* sendQueueSize */
 438   ps->parameterID = PID_SEND_QUEUE_SIZE;
 439   ps->parameterLength = 4;
 440   ps->parameterLocal.asUInt32 = pp->sendQueueSize;
 441   ps->parameter = NULL;
 442   CSChangeAttributes_insert(csChange, ps);
 443   ps++;
 444   /* strength */
 445   ps->parameterID = PID_STRENGTH;
 446   ps->parameterLength = 4;
 447   ps->parameterLocal.asUInt32 = pp->strength;
 448   ps->parameter = NULL;
 449   CSChangeAttributes_insert(csChange, ps);
 450   ps++;
 451   /* topic */
 452   parameterPutString(ps, PID_TOPIC, pp->topic);
 453   CSChangeAttributes_insert(csChange, ps);
 454   ps++;
 455   /* typeCheckSum */
 456   ps->parameterID = PID_TYPE_CHECKSUM;
 457   ps->parameterLength = 4;
 458   ps->parameterLocal.asUInt32 = pp->typeChecksum;
 459   ps->parameter = NULL;
 460   CSChangeAttributes_insert(csChange, ps);
 461   ps++;
 462   /* typeName */
 463   parameterPutString(ps, PID_TYPE_NAME, pp->typeName);
 464   CSChangeAttributes_insert(csChange, ps);
 465   ps++;
 466   /* sentinel -> end */
 467   ps->parameterID = PID_SENTINEL;
 468   ps->parameterLength = 0;
 469   ps->parameter = NULL;
 470   CSChangeAttributes_insert(csChange, ps);
 471   return 0;
 472 }
 473
 474 /*****************************************************************************/
 475 int
 476 parameterUpdateCSChangeFromSubscription(CSChange *csChange, ORTESubsProp *sp)
 477 {
 478   ParameterSequence *ps;
 479
 480   CSChangeAttributes_init_head(csChange);
 481   ps = (ParameterSequence *)MALLOC(sizeof(ParameterSequence)*8);
 482   //minimum separation
 483   ps->parameterID = PID_MINIMUM_SEPARATION;
 484   ps->parameterLength = 8;
 485   memcpy(ps->parameterLocal.asStr, &sp->minimumSeparation, ps->parameterLength);
 486   ps->parameter = NULL;
 487   CSChangeAttributes_insert(csChange, ps);
 488   ps++;
 489   /* receive queue size*/
 490   ps->parameterID = PID_RECV_QUEUE_SIZE;
 491   ps->parameterLength = 4;
 492   ps->parameterLocal.asUInt32 = sp->recvQueueSize;
 493   ps->parameter = NULL;
 494   CSChangeAttributes_insert(csChange, ps);
 495   ps++;
 496   /* reliabitityRequested */
 497   ps->parameterID = PID_RELIABILITY_REQUESTED;
 498   ps->parameterLength = 4;
 499   ps->parameterLocal.asUInt32 = sp->reliabilityRequested;
 500   ps->parameter = NULL;
 501   CSChangeAttributes_insert(csChange, ps);
 502   ps++;
 503   /* topic */
 504   parameterPutString(ps, PID_TOPIC, sp->topic);
 505   CSChangeAttributes_insert(csChange, ps);
 506   ps++;
 507   /* typeCheckSum */
 508   ps->parameterID = PID_TYPE_CHECKSUM;
 509   ps->parameterLength = 4;
 510   ps->parameterLocal.asUInt32 = sp->typeChecksum;
 511   ps->parameter = NULL;
 512   CSChangeAttributes_insert(csChange, ps);
 513   ps++;
 514   /* typeName */
 515   parameterPutString(ps, PID_TYPE_NAME, sp->typeName);
 516   CSChangeAttributes_insert(csChange, ps);
 517   ps++;
 518   /* userdata multicast ipaddress */
 519   ps->parameterID = PID_USERDATA_MULTICAST_IPADDRESS;
 520   ps->parameterLength = 4;
 521   ps->parameterLocal.asIPAddress = sp->multicast;
 522   ps->parameter = NULL;
 523   CSChangeAttributes_insert(csChange, ps);
 524   ps++;
 525   /* sentinel -> end */
 526   ps->parameterID = PID_SENTINEL;
 527   ps->parameterLength = 0;
 528   ps->parameter = NULL;
 529   CSChangeAttributes_insert(csChange, ps);
 530   return 0;
 531 }
 532
 533 /*****************************************************************************/
 534 int
 535 parameterUpdateApplication(CSChange *csChange, AppParams *ap)
 536 {
 537   ParameterSequence   *ps;
 538
 539   ap->managerKeyCount = 0;
 540   ap->metatrafficMulticastIPAddressCount = 0;
 541   ap->unicastIPAddressCount = 0;
 542   ap->appId = csChange->guid.aid;
 543   ap->hostId = csChange->guid.hid;
 544   ul_list_for_each(CSChangeAttributes, csChange, ps) {
 545     switch (ps->parameterID) {
 546       case PID_EXPIRATION_TIME:
 547         ap->expirationTime = ps->parameterLocal.asNtpTime;
 548         break;
 549       case PID_MANAGER_KEY:
 550         ap->managerKeyList[ap->managerKeyCount] =
 551           ps->parameterLocal.asUInt32;
 552         ap->managerKeyCount++;
 553         break;
 554       case PID_MATATRAFFIC_MULTICAST_IPADDRESS:
 555         ap->metatrafficMulticastIPAddressList[ap->metatrafficMulticastIPAddressCount] =
 556           ps->parameterLocal.asIPAddress;
 557         ap->metatrafficMulticastIPAddressCount++;
 558         break;
 559       case PID_APP_IPADDRESS:
 560         ap->unicastIPAddressList[ap->unicastIPAddressCount] =
 561           ps->parameterLocal.asIPAddress;
 562         ap->unicastIPAddressCount++;
 563         break;
 564       case PID_USERDATA_MULTICAST_IPADDRESS:
 565         break;
 566       case PID_METATRAFFIC_UNICAST_PORT:
 567         ap->metatrafficUnicastPort = ps->parameterLocal.asPort;
 568         break;
 569       case PID_USERDATA_UNICAST_PORT:
 570         ap->userdataUnicastPort = ps->parameterLocal.asPort;
 571         break;
 572       case PID_VENDOR_ID:
 573         ap->vendorId = ps->parameterLocal.asVendorId;
 574         break;
 575       case PID_PROTOCOL_VERSION:
 576         ap->protocolVersion = ps->parameterLocal.asProtocolVersion;
 577         break;
 578       case PID_VARGAPPS_SEQUENCE_NUMBER_LAST:
 579         ap->vargAppsSequenceNumber = ps->parameterLocal.asSequenceNumber;
 580         break;
 581     }
 582   }
 583   return 0;
 584 }
 585
 586 /*****************************************************************************/
 587 int
 588 parameterUpdatePublication(CSChange *csChange, ORTEPublProp *pp)
 589 {
 590   ParameterSequence   *ps;
 591
 592   ul_list_for_each(CSChangeAttributes, csChange, ps) {
 593     switch (ps->parameterID) {
 594       case PID_EXPECTS_ACK:
 595         pp->expectsAck = *(Boolean *)&ps->parameterLocal;
 596         break;
 597       case PID_PERSISTENCE:
 598         pp->persistence = ps->parameterLocal.asNtpTime;
 599         break;
 600       case PID_RELIABILITY_OFFERED:
 601         pp->reliabilityOffered = ps->parameterLocal.asUInt32;
 602         break;
 603       case PID_SEND_QUEUE_SIZE:
 604         pp->sendQueueSize = ps->parameterLocal.asUInt32;
 605         break;
 606       case PID_STRENGTH:
 607         pp->strength = ps->parameterLocal.asUInt32;
 608         break;
 609       case PID_TOPIC:
 610         if (ps->parameterLength > MAX_PARAMETER_LOCAL_LENGTH)
 611           strncpy((char *)pp->topic, (const char *)ps->parameter, ps->parameterLength);
 612         else
 613           strncpy((char *)pp->topic, (const char *)ps->parameterLocal.asStr, ps->parameterLength);
 614         break;
 615       case PID_TYPE_CHECKSUM:
 616         pp->typeChecksum = ps->parameterLocal.asTypeChecksum;
 617         break;
 618       case PID_TYPE_NAME:
 619         if (ps->parameterLength > MAX_PARAMETER_LOCAL_LENGTH)
 620           strncpy((char *)pp->typeName, (const char *)ps->parameter, ps->parameterLength);
 621         else
 622           strncpy((char *)pp->typeName, (const char *)ps->parameterLocal.asStr, ps->parameterLength);
 623         break;
 624     }
 625   }
 626   return 0;
 627 }
 628
 629 /*****************************************************************************/
 630 int
 631 parameterUpdateSubscription(CSChange *csChange, ORTESubsProp *sp)
 632 {
 633   ParameterSequence   *ps;
 634
 635   ul_list_for_each(CSChangeAttributes, csChange, ps) {
 636     switch (ps->parameterID) {
 637       case PID_MINIMUM_SEPARATION:
 638         sp->minimumSeparation = ps->parameterLocal.asNtpTime;
 639         break;
 640       case PID_RECV_QUEUE_SIZE:
 641         sp->recvQueueSize = ps->parameterLocal.asUInt32;
 642         break;
 643       case PID_RELIABILITY_REQUESTED:
 644         sp->reliabilityRequested = ps->parameterLocal.asUInt32;
 645         break;
 646       case PID_TOPIC:
 647         if (ps->parameterLength > MAX_PARAMETER_LOCAL_LENGTH)
 648           strncpy((char *)sp->topic, (const char *)ps->parameter, ps->parameterLength);
 649         else
 650           strncpy((char *)sp->topic, (const char *)ps->parameterLocal.asStr, ps->parameterLength);
 651         break;
 652       case PID_TYPE_CHECKSUM:
 653         sp->typeChecksum = ps->parameterLocal.asTypeChecksum;
 654         break;
 655       case PID_TYPE_NAME:
 656         if (ps->parameterLength > MAX_PARAMETER_LOCAL_LENGTH)
 657           strncpy((char *)sp->typeName, (const char *)ps->parameter, ps->parameterLength);
 658         else
 659           strncpy((char *)sp->typeName, (const char *)ps->parameterLocal.asStr, ps->parameterLength);
 660         break;
 661       case PID_USERDATA_MULTICAST_IPADDRESS:
 662         sp->multicast = ps->parameterLocal.asIPAddress;
 663         break;
 664     }
 665   }
 666   return 0;
 667 }