orte/liborte/parameter.c

   1 /*
   2  *  $Id: parameter.c,v 0.0.0.1          2003/10/13
   3  *
   4  *  DEBUG:  section 11                  parameter
   5  *  AUTHOR: Petr Smolik                 petr.smolik@wo.cz
   6  *
   7  *  ORTE - OCERA Real-Time Ethernet     http://www.ocera.org/
   8  *  --------------------------------------------------------------------
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  */
  21
  22 #include "orte.h"
  23
  24 /*****************************************************************************/
  25 int
  26 parameterDelete(CSChange *csChange) {
  27   ParameterSequence *ps;
  28
  29   ul_list_for_each(CSChangeAttributes,
  30                    csChange,
  31                    ps) {
  32     if ((ps->parameterLength) > MAX_PARAMETER_LOCAL_LENGTH)
  33       FREE(ps->parameter);
  34   }
  35   //ps is like one piece of memory
  36   if (CSChangeAttributes_first(csChange))
  37     FREE(CSChangeAttributes_first(csChange));
  38   CSChangeAttributes_init_head(csChange);
  39   return ORTE_TRUE;
  40 }
  41
  42
  43 /*****************************************************************************/
  44 int
  45 parameterCodeStreamFromCSChange(CSChange *csChange,
  46     uint8_t *rtps_msg,uint32_t max_msg_len) {
  47   ParameterSequence *ps;
  48   int               result=0;
  49
  50   ul_list_for_each(CSChangeAttributes,
  51                    csChange,
  52                    ps) {
  53     if (max_msg_len<(uint32_t)(4+ps->parameterLength)) return -1; //no memory for copy
  54     *((ParameterId*)rtps_msg)=ps->parameterID;
  55     *((ParameterLength*)(rtps_msg+2))=ps->parameterLength;
  56     if (ps->parameterLength>MAX_PARAMETER_LOCAL_LENGTH) {
  57       memcpy(rtps_msg+4,ps->parameter,ps->parameterLength);
  58     } else {
  59       memcpy(rtps_msg+4,ps->parameterLocal,ps->parameterLength);
  60     }
  61     rtps_msg=rtps_msg+4+ps->parameterLength;
  62     max_msg_len=max_msg_len-ps->parameterLength-4;
  63     result=result+4+ps->parameterLength;
  64   }
  65   return result;
  66 }
  67
  68 /*****************************************************************************/
  69 int
  70 parameterDecodeStreamToCSChange(CSChange *csChange,uint8_t *rtps_msg,
  71     uint16_t submsg_len,uint8_t e_bit) {
  72   ParameterId       parameterId;
  73   ParameterLength   parameterLength;
  74   ParameterSequence *ps;
  75   uint16_t          counter=0;
  76   uint8_t           *rtps_msg_it=rtps_msg;
  77
  78   CSChangeAttributes_init_head(csChange);
  79   //count number of parameters
  80   while (submsg_len) {
  81     parameterId=*((ParameterId*)rtps_msg_it);
  82     conv_u16(&parameterId,e_bit);
  83     parameterLength=*((ParameterId*)(rtps_msg_it+2));
  84     conv_u16(&parameterLength,e_bit);
  85     if (submsg_len>parameterLength) submsg_len-=parameterLength;
  86     else submsg_len=0;
  87     if (parameterId==PID_SENTINEL) break;
  88     counter++;
  89     rtps_msg_it+=4+parameterLength;
  90   }
  91   ps=(ParameterSequence*)MALLOC(sizeof(ParameterSequence)*(counter+1));
  92   rtps_msg_it=rtps_msg;
  93   while (counter) {
  94     parameterId=*((ParameterId*)rtps_msg_it);
  95     conv_u16(&parameterId,e_bit);
  96     ps->parameterID=parameterId;
  97     parameterLength=*((ParameterId*)(rtps_msg_it+2));
  98     conv_u16(&parameterLength,e_bit);
  99     ps->parameterLength=parameterLength;
 100     ps->parameter=NULL;
 101     switch (parameterId) {
 102       case PID_SENTINEL:
 103         counter=1;
 104         break;
 105       //NtpTime
 106       case PID_EXPIRATION_TIME:
 107       case PID_PERSISTENCE:
 108       case PID_MINIMUM_SEPARATION:
 109         *(NtpTime*)ps->parameterLocal=*((NtpTime*)(rtps_msg_it+4));
 110         conv_ntp((NtpTime*)ps->parameterLocal,e_bit);
 111         break;
 112       //unsigned long
 113       case PID_TYPE_CHECKSUM:
 114       case PID_STRENGTH:
 115       case PID_SEND_QUEUE_SIZE:
 116       case PID_RECV_QUEUE_SIZE:
 117       case PID_RELIABILITY_OFFERED:
 118       case PID_RELIABILITY_REQUESTED:
 119       case PID_MANAGER_KEY:
 120         *(uint32_t*)ps->parameterLocal=*((uint32_t*)(rtps_msg_it+4));
 121         conv_u32((uint32_t*)ps->parameterLocal,e_bit);
 122         break;
 123       //IPAddress
 124       case PID_MATATRAFFIC_MULTICAST_IPADDRESS:
 125       case PID_APP_IPADDRESS:
 126       case PID_USERDATA_MULTICAST_IPADDRESS:
 127         *(IPAddress*)ps->parameterLocal=*((IPAddress*)(rtps_msg_it+4));
 128         conv_u32((IPAddress*)ps->parameterLocal,e_bit);
 129         break;
 130       //Port
 131       case PID_METATRAFFIC_UNICAST_PORT:
 132       case PID_USERDATA_UNICAST_PORT:
 133         *(Port*)ps->parameterLocal=*((Port*)(rtps_msg_it+4));
 134         conv_u32((Port*)ps->parameterLocal,e_bit);
 135         break;
 136       //VendorId
 137       case PID_VENDOR_ID:
 138         *(VendorId*)ps->parameterLocal=*((VendorId*)(rtps_msg_it+4));
 139         break;
 140       //ProtocolVersion
 141       case PID_PROTOCOL_VERSION:
 142         *(ProtocolVersion*)ps->parameterLocal=*((ProtocolVersion*)(rtps_msg_it+4));
 143         break;
 144       //SequenceNumber
 145       case PID_VARGAPPS_SEQUENCE_NUMBER_LAST:
 146         *(SequenceNumber*)ps->parameterLocal=*((SequenceNumber*)(rtps_msg_it+4));
 147         conv_sn((SequenceNumber*)ps->parameterLocal,e_bit);
 148         break;
 149       //Boolean
 150       case PID_EXPECTS_ACK:
 151         *(Boolean*)ps->parameterLocal=*((Boolean*)(rtps_msg_it+4));
 152         break;
 153       //PathName,TypeName
 154       case PID_TOPIC:
 155       case PID_TYPE_NAME:
 156         if (ps->parameterLength>MAX_PARAMETER_LOCAL_LENGTH) {
 157           ps->parameter=MALLOC(ps->parameterLength);
 158           memcpy(ps->parameter,rtps_msg_it+4,ps->parameterLength);
 159         } else {
 160           memcpy(ps->parameterLocal,rtps_msg_it+4,ps->parameterLength);
 161         }
 162         break;
 163       case PID_PAD:
 164         break;
 165     }
 166     CSChangeAttributes_insert(csChange,ps);
 167     ps++; //next ps
 168     counter--;
 169     rtps_msg_it+=4+parameterLength;
 170   }
 171   //SENTINEL
 172   ps->parameterID=PID_SENTINEL;
 173   ps->parameterLength=0;
 174   ps->parameter=NULL;
 175   CSChangeAttributes_insert(csChange,ps);
 176   return ORTE_TRUE;
 177 }
 178
 179 /*****************************************************************************/
 180 int
 181 parameterUpdateCSChange(
 182      CSChange *csChange,AppParams *ap,Boolean Manager) {
 183   ParameterSequence *ps;
 184   int               i;
 185
 186   i=ap->managerKeyCount+
 187     ap->metatrafficMulticastIPAddressCount+
 188     ap->unicastIPAddressCount+7;
 189   if (!Manager) i--;
 190   CSChangeAttributes_init_head(csChange);
 191   ps=(ParameterSequence*)MALLOC(sizeof(ParameterSequence)*i);
 192   //EXPIRATION_TIME
 193   ps->parameterID=PID_EXPIRATION_TIME;
 194   ps->parameterLength=8;
 195   memcpy(ps->parameterLocal,&ap->expirationTime,ps->parameterLength);
 196   ps->parameter=NULL;
 197   CSChangeAttributes_insert(csChange,ps);
 198   ps++;
 199   //MATATRAFFIC_MULTICAST_IPADDRESS
 200   for (i=0;i<ap->metatrafficMulticastIPAddressCount;i++) {
 201     ps->parameterID=PID_MATATRAFFIC_MULTICAST_IPADDRESS;
 202     ps->parameterLength=4;
 203     *(IPAddress*)ps->parameterLocal=ap->metatrafficMulticastIPAddressList[i];
 204     ps->parameter=NULL;
 205     CSChangeAttributes_insert(csChange,ps);
 206     ps++;
 207   }
 208   //METATRAFFIC_UNICAST_PORT
 209   ps->parameterID=PID_METATRAFFIC_UNICAST_PORT;
 210   ps->parameterLength=4;
 211   *(Port*)&ps->parameterLocal=ap->metatrafficUnicastPort;
 212   ps->parameter=NULL;
 213   CSChangeAttributes_insert(csChange,ps);
 214   ps++;
 215   //USERDATA_UNICAST_PORT
 216   ps->parameterID=PID_USERDATA_UNICAST_PORT;
 217   ps->parameterLength=4;
 218   *(Port*)&ps->parameterLocal=ap->userdataUnicastPort;
 219   ps->parameter=NULL;
 220   CSChangeAttributes_insert(csChange,ps);
 221   ps++;
 222   //APP_IPADDRESS
 223   for (i=0;i<ap->unicastIPAddressCount;i++) {
 224     ps->parameterID=PID_APP_IPADDRESS;;
 225     ps->parameterLength=4;
 226     *(IPAddress*)ps->parameterLocal=ap->unicastIPAddressList[i];
 227     ps->parameter=NULL;
 228     CSChangeAttributes_insert(csChange,ps);
 229     ps++;
 230   }
 231   //PROTOCOL_VERSION
 232   ps->parameterID=PID_PROTOCOL_VERSION;
 233   ps->parameterLength=2;
 234   *(ProtocolVersion*)&ps->parameterLocal=ap->protocolVersion;
 235   ps->parameter=NULL;
 236   CSChangeAttributes_insert(csChange,ps);
 237   ps++;
 238   //VENDOR_ID
 239   ps->parameterID=PID_VENDOR_ID;
 240   ps->parameterLength=2;
 241   *(VendorId*)&ps->parameterLocal=ap->vendorId;
 242   ps->parameter=NULL;
 243   CSChangeAttributes_insert(csChange,ps);
 244   ps++;
 245   if (Manager) {    //Manager
 246     //VARGAPPS_SEQUENCE_NUMBER_LAST
 247     ps->parameterID=PID_VARGAPPS_SEQUENCE_NUMBER_LAST;
 248     ps->parameterLength=8;
 249     *(SequenceNumber*)&ps->parameterLocal=ap->vargAppsSequenceNumber;
 250     ps->parameter=NULL;
 251     CSChangeAttributes_insert(csChange,ps);
 252     ps++;
 253   }
 254   //MANAGER_KEY
 255   for (i=0;i<ap->managerKeyCount;i++) {
 256     ps->parameterID=PID_MANAGER_KEY;
 257     ps->parameterLength=4;
 258     *(uint32_t*)ps->parameterLocal=ap->managerKeyList[i];
 259     ps->parameter=NULL;
 260     CSChangeAttributes_insert(csChange,ps);
 261     ps++;
 262   }
 263   //SENTINEL
 264   ps->parameterID=PID_SENTINEL;
 265   ps->parameterLength=0;
 266   ps->parameter=NULL;
 267   CSChangeAttributes_insert(csChange,ps);
 268   return 0;
 269 }
 270
 271 /*****************************************************************************/
 272 int
 273 parameterUpdateCSChangeFromPublication(CSChange *csChange,ORTEPublProp *pp) {
 274   int               len;
 275   ParameterSequence *ps;
 276
 277   CSChangeAttributes_init_head(csChange);
 278   ps=(ParameterSequence*)MALLOC(sizeof(ParameterSequence)*8);
 279   //persistence
 280   ps->parameterID=PID_PERSISTENCE;
 281   ps->parameterLength=8;
 282   memcpy(ps->parameterLocal,&pp->persistence,ps->parameterLength);
 283   ps->parameter=NULL;
 284   CSChangeAttributes_insert(csChange,ps);
 285   ps++;
 286   /* reliabitityOffered */
 287   ps->parameterID=PID_RELIABILITY_OFFERED;
 288   ps->parameterLength=4;
 289   *(uint32_t*)ps->parameterLocal=pp->reliabilityOffered;
 290   ps->parameter=NULL;
 291   CSChangeAttributes_insert(csChange,ps);
 292   ps++;
 293   /* sendQueueSize */
 294   ps->parameterID=PID_SEND_QUEUE_SIZE;
 295   ps->parameterLength=4;
 296   *(uint32_t*)ps->parameterLocal=pp->sendQueueSize;
 297   ps->parameter=NULL;
 298   CSChangeAttributes_insert(csChange,ps);
 299   ps++;
 300   /* strength */
 301   ps->parameterID=PID_STRENGTH;
 302   ps->parameterLength=4;
 303   *(uint32_t*)ps->parameterLocal=pp->strength;
 304   ps->parameter=NULL;
 305   CSChangeAttributes_insert(csChange,ps);
 306   ps++;
 307   /* topic */
 308   ps->parameterID=PID_TOPIC;
 309   len=strlen(pp->topic);
 310   ps->parameter=(int8_t*)MALLOC(len+8);
 311   *(uint32_t*)ps->parameter=len+1;
 312   strncpy((4+ps->parameter),pp->topic,len);
 313   *(uint32_t*)(ps->parameter+len+4)=0;
 314   ps->parameterLength=len+8;
 315   CSChangeAttributes_insert(csChange,ps);
 316   ps++;
 317   /* typeCheckSum */
 318   ps->parameterID=PID_TYPE_CHECKSUM;
 319   ps->parameterLength=4;
 320   *(uint32_t*)ps->parameterLocal=pp->typeChecksum;
 321   ps->parameter=NULL;
 322   CSChangeAttributes_insert(csChange,ps);
 323   ps++;
 324   /* typeName */
 325   ps->parameterID=PID_TYPE_NAME;
 326   len=strlen(pp->typeName);
 327   ps->parameter=(int8_t*)MALLOC(len+8);
 328   *(uint32_t*)ps->parameter=len+1;
 329   strncpy((4+ps->parameter),pp->typeName,len);
 330   *(uint32_t*)(ps->parameter+len+4)=0;
 331   ps->parameterLength=len+8;
 332   CSChangeAttributes_insert(csChange,ps);
 333   ps++;
 334   /* sentinel -> end */
 335   ps->parameterID=PID_SENTINEL;
 336   ps->parameterLength=0;
 337   ps->parameter=NULL;
 338   CSChangeAttributes_insert(csChange,ps);
 339   return 0;
 340 }
 341
 342 /*****************************************************************************/
 343 int
 344 parameterUpdateCSChangeFromSubscription(CSChange *csChange,ORTESubsProp *sp) {
 345   int               len;
 346   ParameterSequence *ps;
 347
 348   CSChangeAttributes_init_head(csChange);
 349   ps=(ParameterSequence*)MALLOC(sizeof(ParameterSequence)*7);
 350   //minimum separation
 351   ps->parameterID=PID_MINIMUM_SEPARATION;
 352   ps->parameterLength=8;
 353   memcpy(ps->parameterLocal,&sp->minimumSeparation,ps->parameterLength);
 354   ps->parameter=NULL;
 355   CSChangeAttributes_insert(csChange,ps);
 356   ps++;
 357   /* receive queue size*/
 358   ps->parameterID=PID_RECV_QUEUE_SIZE;
 359   ps->parameterLength=4;
 360   *(uint32_t*)ps->parameterLocal=sp->recvQueueSize;
 361   ps->parameter=NULL;
 362   CSChangeAttributes_insert(csChange,ps);
 363   ps++;
 364   /* reliabitityRequested */
 365   ps->parameterID=PID_RELIABILITY_REQUESTED;
 366   ps->parameterLength=4;
 367   *(uint32_t*)ps->parameterLocal=sp->reliabilityRequested;
 368   ps->parameter=NULL;
 369   CSChangeAttributes_insert(csChange,ps);
 370   ps++;
 371   /* topic */
 372   ps->parameterID=PID_TOPIC;
 373   len=strlen(sp->topic);
 374   ps->parameter=(int8_t*)MALLOC(len+8);
 375   *(uint32_t*)ps->parameter=len+1;
 376   strncpy((4+ps->parameter),sp->topic,len);
 377   *(uint32_t*)(ps->parameter+len+4)=0;
 378   ps->parameterLength=len+8;
 379   CSChangeAttributes_insert(csChange,ps);
 380   ps++;
 381   /* typeCheckSum */
 382   ps->parameterID=PID_TYPE_CHECKSUM;
 383   ps->parameterLength=4;
 384   *(uint32_t*)ps->parameterLocal=sp->typeChecksum;
 385   ps->parameter=NULL;
 386   CSChangeAttributes_insert(csChange,ps);
 387   ps++;
 388   /* typeName */
 389   ps->parameterID=PID_TYPE_NAME;
 390   len=strlen(sp->typeName);
 391   ps->parameter=(int8_t*)MALLOC(len+8);
 392   *(uint32_t*)ps->parameter=len+1;
 393   strncpy((4+ps->parameter),sp->typeName,len);
 394   *(uint32_t*)(ps->parameter+len+4)=0;
 395   ps->parameterLength=len+8;
 396   CSChangeAttributes_insert(csChange,ps);
 397   ps++;
 398   /* sentinel -> end */
 399   ps->parameterID=PID_SENTINEL;
 400   ps->parameterLength=0;
 401   ps->parameter=NULL;
 402   CSChangeAttributes_insert(csChange,ps);
 403   return 0;
 404 }
 405
 406 /*****************************************************************************/
 407 int
 408 parameterUpdateApplication(CSChange *csChange,AppParams *ap) {
 409   ParameterSequence   *ps;
 410
 411   ap->managerKeyCount=0;
 412   ap->metatrafficMulticastIPAddressCount=0;
 413   ap->unicastIPAddressCount=0;
 414   ap->appId=csChange->guid.aid;
 415   ap->hostId=csChange->guid.hid;
 416   ul_list_for_each(CSChangeAttributes,csChange,ps) {
 417     switch (ps->parameterID) {
 418       case PID_EXPIRATION_TIME:
 419         ap->expirationTime=*(NtpTime*)ps->parameterLocal;
 420         break;
 421       case PID_MANAGER_KEY:
 422         ap->managerKeyList[ap->managerKeyCount]=
 423             *(uint32_t*)ps->parameterLocal;
 424         ap->managerKeyCount++;
 425         break;
 426       case PID_MATATRAFFIC_MULTICAST_IPADDRESS:
 427         ap->metatrafficMulticastIPAddressList[ap->metatrafficMulticastIPAddressCount]=
 428             *(IPAddress*)ps->parameterLocal;
 429         ap->metatrafficMulticastIPAddressCount++;
 430         break;
 431       case PID_APP_IPADDRESS:
 432         ap->unicastIPAddressList[ap->unicastIPAddressCount]=
 433             *(IPAddress*)ps->parameterLocal;
 434         ap->unicastIPAddressCount++;
 435         break;
 436       case PID_USERDATA_MULTICAST_IPADDRESS:
 437         break;
 438       case PID_METATRAFFIC_UNICAST_PORT:
 439         ap->metatrafficUnicastPort=*(Port*)ps->parameterLocal;
 440         break;
 441       case PID_USERDATA_UNICAST_PORT:
 442         ap->userdataUnicastPort=*(Port*)ps->parameterLocal;
 443         break;
 444       case PID_VENDOR_ID:
 445         ap->vendorId=*(VendorId*)ps->parameterLocal;
 446         break;
 447       case PID_PROTOCOL_VERSION:
 448         ap->protocolVersion=*(ProtocolVersion*)ps->parameterLocal;
 449         break;
 450       case PID_VARGAPPS_SEQUENCE_NUMBER_LAST:
 451         ap->vargAppsSequenceNumber=*(SequenceNumber*)ps->parameterLocal;
 452         break;
 453     }
 454   }
 455   return 0;
 456 }
 457
 458 /*****************************************************************************/
 459 int
 460 parameterUpdatePublication(CSChange *csChange,ORTEPublProp *pp) {
 461   ParameterSequence   *ps;
 462
 463   ul_list_for_each(CSChangeAttributes,csChange,ps) {
 464     switch (ps->parameterID) {
 465       case PID_EXPECTS_ACK:
 466         pp->expectsAck=*(Boolean*)&ps->parameterLocal;
 467       break;
 468       case PID_PERSISTENCE:
 469         pp->persistence=*(NtpTime*)&ps->parameterLocal;
 470       break;
 471       case PID_RELIABILITY_OFFERED:
 472         pp->reliabilityOffered=*(u_long*)&ps->parameterLocal;
 473       break;
 474       case PID_SEND_QUEUE_SIZE:
 475         pp->sendQueueSize=*(u_long*)&ps->parameterLocal;
 476       break;
 477       case PID_STRENGTH:
 478         pp->strength=*(int32_t*)&ps->parameterLocal;
 479       break;
 480       case PID_TOPIC:
 481         if (ps->parameterLength>MAX_PARAMETER_LOCAL_LENGTH)
 482           strncpy(pp->topic,ps->parameter+4,ps->parameterLength-3);
 483         else
 484           strncpy(pp->topic,ps->parameterLocal+4,ps->parameterLength-3);
 485       break;
 486       case PID_TYPE_CHECKSUM:
 487         pp->typeChecksum=*(TypeChecksum*)&ps->parameterLocal;
 488       break;
 489       case PID_TYPE_NAME:
 490         if (ps->parameterLength>MAX_PARAMETER_LOCAL_LENGTH)
 491           strncpy(pp->typeName,ps->parameter+4,ps->parameterLength-3);
 492         else
 493           strncpy(pp->typeName,ps->parameterLocal+4,ps->parameterLength-3);
 494       break;
 495     }
 496   }
 497   return 0;
 498 }
 499
 500 /*****************************************************************************/
 501 int
 502 parameterUpdateSubscription(CSChange *csChange,ORTESubsProp *sp) {
 503   ParameterSequence   *ps;
 504
 505   ul_list_for_each(CSChangeAttributes,csChange,ps) {
 506     switch (ps->parameterID) {
 507       case PID_MINIMUM_SEPARATION:
 508         sp->minimumSeparation=*(NtpTime*)&ps->parameterLocal;
 509       break;
 510       case PID_RECV_QUEUE_SIZE:
 511         sp->recvQueueSize=*(uint32_t*)&ps->parameterLocal;
 512       break;
 513       case PID_RELIABILITY_REQUESTED:
 514         sp->reliabilityRequested=*(uint32_t*)&ps->parameterLocal;
 515       break;
 516       case PID_TOPIC:
 517         if (ps->parameterLength>MAX_PARAMETER_LOCAL_LENGTH)
 518           strncpy(sp->topic,ps->parameter+4,ps->parameterLength-3);
 519         else
 520           strncpy(sp->topic,ps->parameterLocal+4,ps->parameterLength-3);
 521       break;
 522       case PID_TYPE_CHECKSUM:
 523         sp->typeChecksum=*(TypeChecksum*)&ps->parameterLocal;
 524       break;
 525       case PID_TYPE_NAME:
 526         if (ps->parameterLength>MAX_PARAMETER_LOCAL_LENGTH)
 527           strncpy(sp->typeName,ps->parameter+4,ps->parameterLength-3);
 528         else
 529           strncpy(sp->typeName,ps->parameterLocal+4,ps->parameterLength-3);
 530       break;
 531     }
 532   }
 533   return 0;
 534 }
 535