online_distribution/eventlibraries/Cpacket.C

0001 /*
0002 ** Cpacket.C
0003 **
0004 ** Author: $Author: phoncs $
0005 **   Date: $Date: 2004/02/14 00:17:03 $
0006 **
0007 ** $Log: Cpacket.C,v $
0008 ** Revision 1.2  2004/02/14 00:17:03  phoncs
0009 ** J.J change by brian to fix the padding problem
0010 **
0011 ** Revision 1.1.1.1  2000/07/21 01:51:10  purschke
0012 ** mlp -- adding the new automakified "basic" module to CVS.
0013 **
0014 **
0015 ** Revision 1.6  1998/12/17 15:18:16  phoncs
0016 ** (stephen markacs) more bounds checking in Cpacket.C (one instance) and removal of debugging comments from checkFrame.C
0017 **
0018 ** Revision 1.5  1998/12/11 22:01:59  markacs
0019 ** (stephen markacs) adding log into cvs tags
0020 **
0021 */
0022 /*
0023 **  These are the version independent functions which
0024 **  provide access to and mocification of information
0025 **  in the header, but which are not inlined.
0026 **
0027 */
0028
0029 #include "phenixOnline.h"
0030 #include "packetPublic.h"
0031 #include "packetHdr.h"
0032 #include "Cpacket.h"
0033 #include "CpacketV1.h"
0034
0035 PTR_ret findPacketEnd (PACKET_ptr packet_ptr)
0036 {
0037 #ifdef STRONGCHECK
0038   if (!validPacketHdr(packet_ptr)) {
0039     setPacketError(FORMAT_ERR_INVALID_HDR, packet_ptr, 0);
0040     return logicFailure;
0041   }
0042 #endif
0043
0044   PHDWORD packetLength = getPacketLength (packet_ptr);
0045   if (packetLength != valueFailure) {
0046     setPacketSuccess ();
0047     return ((PHDWORD *) packet_ptr + packetLength - 1);
0048   }
0049   else
0050     return ptrFailure;
0051 }
0052
0053 PTR_ret findPacketDataStart (PACKET_ptr packet_ptr)
0054 {
0055   if (validPacketHdr(packet_ptr))
0056     return ((PHDWORD*)packet_ptr + getPacketHdrLength(packet_ptr) +
0057         getPacketDataDescrLength(packet_ptr) - 1);
0058   else
0059     return ptrFailure;
0060 }
0061
0062 /*
0063 ** Adjust the length of the data block in the packet.
0064 **
0065 **  Note: a negative extension is allowed
0066 */
0067 VALUE_ret extendPacketDataBlock(const PACKET_ptr packet_ptr, UINT maxPacketLength,
0068                   int addDwords)
0069 {
0070   /*
0071   ** Extend the packet itself
0072   */
0073   PHDWORD newLength = extendPacketLength (packet_ptr, maxPacketLength, addDwords);
0074
0075   /*
0076   ** Update the length of the data block itself (NOOP for V1)
0077   */
0078   if (newLength != valueFailure) {
0079     return adjustPacketDataLength(packet_ptr, addDwords);
0080   }
0081   else
0082     return valueFailure;
0083 }
0084
0085 /*
0086 ** Adjust the length of the debug block in the packet.
0087 **
0088 **  Note: a negative extension is allowed
0089 */
0090 VALUE_ret extendPacketDebugBlock(const PACKET_ptr packet_ptr,  UINT maxPacketLength,
0091                  int addDwords)
0092 {
0093   /*
0094   ** Extend the packet itself
0095   */
0096   PHDWORD newLength = extendPacketLength (packet_ptr, maxPacketLength, addDwords);
0097
0098   /*
0099   ** Update the length of the debug blcok itself (NOOP) for V1
0100   */
0101   if (newLength != valueFailure)
0102     return adjustPacketDebugLength(packet_ptr, addDwords);
0103   else
0104     return valueFailure;
0105 }
0106
0107
0108 /*
0109 ** Adjust the length of the error block in the packet.
0110 **
0111 **  Note: a negative extension is allowed
0112 */
0113 VALUE_ret extendPacketErrorBlock(const PACKET_ptr packet_ptr,  UINT maxPacketLength,
0114                  int addDwords)
0115 {
0116   /*
0117   ** Extend the packet itself
0118   */
0119   PHDWORD newLength = extendPacketLength (packet_ptr, maxPacketLength, addDwords);
0120
0121   /*
0122   ** Update the length of the debug blcok itself (NOOP) for V1
0123   */
0124   if (newLength != valueFailure)
0125     return adjustPacketErrorLength(packet_ptr, addDwords);
0126   else
0127     return valueFailure;
0128 }
0129
0130
0131 /*
0132 ** Adjust the length of the packet and update the padding count.
0133 **
0134 **  Note: a negative extension is allowed
0135 */
0136 VALUE_ret extendPacketLength(const PACKET_ptr packet_ptr,  UINT maxPacketLength,
0137                  int addDwords)
0138 {
0139   UINT nPadDwords;
0140   PHDWORD newLength;
0141
0142   /*
0143   ** Drop any existing padding.
0144   */
0145   if (!removePacketPadding(packet_ptr)) {
0146     return valueFailure;
0147   }
0148
0149   /*
0150   **  Check for buffer overflow
0151   */
0152   newLength = getPacketLength(packet_ptr) + addDwords;
0153
0154   if (newLength > maxPacketLength) {
0155     setPacketError(FORMAT_ERR_BUFFER_OVERFLOW,packet_ptr,newLength);
0156     return valueFailure;
0157   }
0158
0159   {
0160     /*
0161     **  Now calculate the padding
0162     */
0163     UINT modulo = newLength % packetQuantum;
0164     if (modulo > 0)  nPadDwords = packetQuantum - modulo;
0165     else nPadDwords = 0;
0166   }
0167
0168   newLength += nPadDwords;
0169
0170   /*
0171   ** Store the number of padding words in the header
0172   */
0173   setPacketPadding(packet_ptr, nPadDwords);
0174
0175   /*
0176   ** Update the packet length
0177   */
0178   setPacketLength(packet_ptr, newLength);
0179
0180   return newLength;
0181 }
0182
0183 LOGIC_ret removePacketPadding(PACKET_ptr packet_ptr)
0184 {
0185   /*
0186   ** Get the current number of padding dwords
0187   */
0188   UINT nPadDwords = getPacketPadding(packet_ptr);
0189
0190   /*
0191   ** decrease the packet length by this amount
0192   */
0193   if (nPadDwords > 0) {
0194     PHDWORD newPacketLength = getPacketLength(packet_ptr) - nPadDwords;
0195
0196     /*
0197     ** Check for reasonable result
0198     */
0199     if (newPacketLength < packetV1HdrLength) {
0200       /*
0201       **  Oops, there's a problem. Set error result and return failure.
0202       */
0203       setPacketError(FORMAT_ERR_HDR_INCONSISTENCY,packet_ptr,0);
0204       return logicFailure;
0205     }
0206
0207     /*
0208     **  Update the header length
0209     */
0210     setPacketLength(packet_ptr, newPacketLength);
0211     setPacketPadding(packet_ptr, 0);
0212   }
0213
0214   return logicSuccess;
0215 }
0216
0217
0218 #ifndef DCM
0219 /*
0220 ** Define indirection pointer arrays to various frame access functions
0221 ** To avoid conflict with frame indirection pointer arrays, a "P" has
0222 ** been placed in each definition before the word "FUNCTION".
0223 */
0224 typedef LOGIC_ret CHECKPFUNC (PACKET_ptr);
0225 typedef VALUE_ret ACCESSPFUNC (PACKET_ptr);
0226 typedef VALUE_ret ADJUSTPFUNC (PACKET_ptr, int);
0227 typedef VALUE_ret ORPFUNC (PACKET_ptr, UINT);
0228 typedef PTR_ret   PTRACCESSPFUNC (PACKET_ptr);
0229 typedef LOGIC_ret MODIFYPFUNC (PACKET_ptr, UINT);
0230
0231
0232 typedef ACCESSPFUNC* ACCESSPFUNCPTR_arr[NUM_PACKET_VERSIONS];
0233 typedef PTRACCESSPFUNC* PTRACCESSPFUNCPTR_arr[NUM_PACKET_VERSIONS];
0234 typedef CHECKPFUNC*  CHECKPFUNCPTR_arr[NUM_PACKET_VERSIONS];
0235 typedef MODIFYPFUNC* MODIFYPFUNCPTR_arr[NUM_PACKET_VERSIONS];
0236 typedef ADJUSTPFUNC* ADJUSTPFUNCPTR_arr[NUM_PACKET_VERSIONS];
0237 typedef ORPFUNC* ORPFUNCPTR_arr[NUM_PACKET_VERSIONS];
0238
0239 #ifdef __cplusplus
0240 ACCESSPFUNC* const NULLACCESSPFUNC = 0;
0241 PTRACCESSPFUNC* const NULLPTRACCESSPFUNC = 0;
0242 CHECKPFUNC*  const NULLCHECKPFUNC = 0;
0243 MODIFYPFUNC* const NULLMODIFYPFUNC = 0;
0244 ADJUSTPFUNC* const NULLADJUSTPFUNC = 0;
0245 ORPFUNC* const NULLORPFUNC = 0;
0246 #else
0247 /*
0248 ** Unfortunately for some C compilers we have to lose the benefits of
0249 **   type-checking because const's are not considered valid initializers
0250 */
0251 #define NULLACCESSPFUNC 0
0252 #define NULLPTRACCESSPFUNC 0
0253 #define NULLCHECKPFUNC 0
0254 #define NULLMODIFYPFUNC 0
0255 #define NULLADJUSTPFUNC 0
0256 #define NULLADJUSTDATAPFUNC 0
0257 #define NULLORPFUNC 0
0258 #endif
0259
0260
0261 ACCESSPFUNCPTR_arr CONSTANT getPacketDataLengthV = {NULLACCESSPFUNC, &getPacketV1DataLength};
0262 ACCESSPFUNCPTR_arr CONSTANT getPacketDebugLengthV = {NULLACCESSPFUNC, &getPacketV1DebugLength};
0263 ACCESSPFUNCPTR_arr CONSTANT getPacketErrorLengthV = {NULLACCESSPFUNC, &getPacketV1ErrorLength};
0264 ACCESSPFUNCPTR_arr CONSTANT getPacketNumErrorsV = {NULLACCESSPFUNC, &getPacketV1NumErrors};
0265 ACCESSPFUNCPTR_arr CONSTANT getPacketEndianismV = {NULLACCESSPFUNC, &getPacketV1Endianism};
0266 ACCESSPFUNCPTR_arr CONSTANT getPacketIdV = {NULLACCESSPFUNC, &getPacketV1Id};
0267 ACCESSPFUNCPTR_arr CONSTANT getPacketPaddingV = {NULLACCESSPFUNC, &getPacketV1Padding};
0268 ACCESSPFUNCPTR_arr CONSTANT getPacketStructureV = {NULLACCESSPFUNC, &getPacketV1Structure};
0269 ACCESSPFUNCPTR_arr CONSTANT getPacketStatusV = {NULLACCESSPFUNC, &getPacketV1Status};
0270 ACCESSPFUNCPTR_arr CONSTANT getPacketDataDescrLengthV = {NULLACCESSPFUNC, &getPacketV1DataDescrLength};
0271
0272 ORPFUNCPTR_arr CONSTANT orPacketStatusV = {NULLORPFUNC, &orPacketV1Status};
0273 ADJUSTPFUNCPTR_arr CONSTANT adjustPacketDataLengthV = {NULLADJUSTPFUNC,
0274                                &adjustPacketV1DataLength};
0275 ADJUSTPFUNCPTR_arr CONSTANT adjustPacketDebugLengthV = {NULLADJUSTPFUNC,
0276                             &adjustPacketV1DebugLength};
0277 ADJUSTPFUNCPTR_arr CONSTANT adjustPacketErrorLengthV = {NULLADJUSTPFUNC,
0278                             &adjustPacketV1ErrorLength};
0279
0280 ORPFUNCPTR_arr CONSTANT makePacketHdrV = {NULLORPFUNC, &makePacketV1Hdr};
0281
0282 MODIFYPFUNCPTR_arr CONSTANT setPacketDebugLengthV = {NULLMODIFYPFUNC, &setPacketV1DebugLength};
0283 MODIFYPFUNCPTR_arr CONSTANT setPacketDataDescrLengthV = {NULLMODIFYPFUNC,
0284                              &setPacketV1DataDescrLength};
0285
0286 MODIFYPFUNCPTR_arr CONSTANT setPacketEndianismV = {NULLMODIFYPFUNC, &setPacketV1Endianism};
0287 MODIFYPFUNCPTR_arr CONSTANT setPacketIdV = {NULLMODIFYPFUNC, &setPacketV1Id};
0288 MODIFYPFUNCPTR_arr CONSTANT setPacketPaddingV = {NULLMODIFYPFUNC, &setPacketV1Padding};
0289 MODIFYPFUNCPTR_arr CONSTANT setPacketErrorLengthV = {NULLMODIFYPFUNC, &setPacketV1ErrorLength};
0290 MODIFYPFUNCPTR_arr CONSTANT setPacketStructureV = {NULLMODIFYPFUNC, &setPacketV1Structure};
0291 MODIFYPFUNCPTR_arr CONSTANT setPacketStatusV = {NULLMODIFYPFUNC, &setPacketV1Status};
0292
0293 PTRACCESSPFUNCPTR_arr CONSTANT findPacketErrorStartV = {NULLPTRACCESSPFUNC,
0294                             &findPacketV1ErrorStart};
0295 PTRACCESSPFUNCPTR_arr CONSTANT findPacketDebugStartV = {NULLPTRACCESSPFUNC,
0296                             &findPacketV1DebugStart};
0297 //PTRACCESSPFUNCPTR_arr CONSTANT findPacketDataStartV = {NULLPTRACCESSPFUNC, &findPacketV1DataStart};
0298 PTRACCESSPFUNCPTR_arr CONSTANT findPacketDataEndV = {NULLPTRACCESSPFUNC, &findPacketV1DataEnd};
0299 PTRACCESSPFUNCPTR_arr CONSTANT findPacketDataDescrV = {NULLPTRACCESSPFUNC,
0300                                &findPacketV1DataDescr};
0301
0302 CHECKPFUNCPTR_arr  CONSTANT validPacketHdrV = {NULLCHECKPFUNC, &validPacketV1Hdr};
0303 CHECKPFUNCPTR_arr  CONSTANT emptyPacketV = {NULLCHECKPFUNC, &emptyPacketV1};
0304
0305 /*
0306 **   "indirection" routines.
0307 **
0308 */
0309
0310 VALUE_ret makePacketHdr (const PACKET_ptr packet_ptr, UINT maxPacketLength)
0311 {
0312   UINT version = currentPacketHdrVersion;
0313   if (version != valueFailure)
0314     return (*makePacketHdrV[version])(packet_ptr, maxPacketLength);
0315   else
0316     return valueFailure;
0317 }
0318
0319
0320 VALUE_ret getPacketStatus (PACKET_ptr packet_ptr)
0321 {
0322   UINT version = getPacketHdrVersion(packet_ptr);
0323   if (version != valueFailure)
0324     return (*getPacketStatusV[version])(packet_ptr);
0325   else
0326     return valueFailure;
0327 }
0328
0329 VALUE_ret orPacketStatus (PACKET_ptr packet_ptr, UINT inBits)
0330 {
0331   UINT version = getPacketHdrVersion(packet_ptr);
0332   if (version != valueFailure)
0333     return (*orPacketStatusV[version])(packet_ptr, inBits);
0334   else
0335     return valueFailure;
0336 }
0337
0338 VALUE_ret getPacketDataLength (const PACKET_ptr packet_ptr)
0339 {
0340   UINT version = getPacketHdrVersion (packet_ptr);
0341   if (version != valueFailure)
0342     return getPacketDataLengthV[version](packet_ptr);
0343   else
0344
0345     return valueFailure;
0346 }
0347
0348 VALUE_ret getPacketErrorLength (const PACKET_ptr packet_ptr)
0349 {
0350   UINT version = getPacketHdrVersion (packet_ptr);
0351   if (version != valueFailure)
0352     return getPacketErrorLengthV[version](packet_ptr);
0353   else
0354
0355     return valueFailure;
0356 }
0357
0358 VALUE_ret getPacketDebugLength (const PACKET_ptr packet_ptr)
0359 {
0360   UINT version = getPacketHdrVersion (packet_ptr);
0361   if (version != valueFailure)
0362     return getPacketDebugLengthV[version](packet_ptr);
0363   else
0364     return valueFailure;
0365 }
0366
0367 VALUE_ret getPacketNumErrors (const PACKET_ptr packet_ptr)
0368 {
0369   UINT version = getPacketHdrVersion (packet_ptr);
0370   if (version != valueFailure)
0371     return getPacketNumErrorsV[version](packet_ptr);
0372   else
0373     return valueFailure;
0374 }
0375
0376 VALUE_ret getPacketId (const PACKET_ptr packet_ptr)
0377 {
0378   UINT version = getPacketHdrVersion (packet_ptr);
0379   if (version != valueFailure)
0380     return getPacketIdV[version](packet_ptr);
0381   else
0382     return valueFailure;
0383 }
0384
0385 VALUE_ret getPacketStructure (const PACKET_ptr packet_ptr)
0386 {
0387   UINT version = getPacketHdrVersion (packet_ptr);
0388   if (version != valueFailure)
0389     return getPacketStructureV[version](packet_ptr);
0390   else return valueFailure;
0391 }
0392
0393 VALUE_ret getPacketEndianism (const PACKET_ptr packet_ptr)
0394 {
0395   UINT version = getPacketHdrVersion (packet_ptr);
0396   if (version != valueFailure)
0397     return getPacketEndianismV[version](packet_ptr);
0398   else
0399     return valueFailure;
0400 }
0401
0402 VALUE_ret getPacketPadding (const PACKET_ptr packet_ptr)
0403 {
0404   UINT version = getPacketHdrVersion (packet_ptr);
0405   if (version != valueFailure)
0406     return getPacketPaddingV[version](packet_ptr);
0407   else
0408     return valueFailure;
0409 }
0410
0411 VALUE_ret getPacketDataDescrLength (const PACKET_ptr packet_ptr)
0412 {
0413   UINT version = getPacketHdrVersion (packet_ptr);
0414   if (version != valueFailure)
0415     return getPacketDataDescrLengthV[version](packet_ptr);
0416   else
0417     return valueFailure;
0418 }
0419
0420
0421 LOGIC_ret setPacketDebugLenth(PACKET_ptr packet_ptr, UINT inLength)
0422 {
0423   UINT version = getPacketHdrVersion (packet_ptr);
0424   if (version != valueFailure)
0425     return setPacketDebugLengthV[version](packet_ptr, inLength);
0426   else
0427     return logicFailure;
0428 }
0429
0430 /*
0431 **  This was commented out up top.
0432 **
0433 **
0434 **  LOGIC_ret setPacketNumErrors(PACKET_ptr packet_ptr, UINT inLength)
0435 **  {
0436 **    UINT version = getPacketHdrVersion (packet_ptr);
0437 **    if (version != valueFailure)
0438 **      return setPacketNumErrorsV[version](packet_ptr, numErrors);
0439 **    else
0440 **      return logicFailure;
0441 **  }
0442 */
0443
0444 LOGIC_ret setPacketId(PACKET_ptr packet_ptr, UINT inId)
0445 {
0446   UINT version = getPacketHdrVersion (packet_ptr);
0447   if (version != valueFailure)
0448     return setPacketIdV[version](packet_ptr, inId);
0449   else
0450     return valueFailure;
0451 }
0452
0453 LOGIC_ret setPacketStructure(PACKET_ptr packet_ptr, UINT structure)
0454 {
0455   UINT version = getPacketHdrVersion (packet_ptr);
0456   if (version != valueFailure)
0457     return setPacketStructureV[version](packet_ptr, structure);
0458   else
0459     return logicFailure;
0460 }
0461
0462 LOGIC_ret setPacketEndianism(PACKET_ptr packet_ptr, UINT endianism)
0463 {
0464   UINT version = getPacketHdrVersion (packet_ptr);
0465   if (version != valueFailure)
0466     return setPacketEndianismV[version](packet_ptr, endianism);
0467   else
0468     return logicFailure;
0469 }
0470
0471 LOGIC_ret setPacketPadding(PACKET_ptr packet_ptr, UINT padding)
0472 {
0473   UINT version = getPacketHdrVersion (packet_ptr);
0474   if (version != valueFailure)
0475     return setPacketPaddingV[version](packet_ptr, padding);
0476   else
0477     return logicFailure;
0478 }
0479
0480 LOGIC_ret setPacketStatus(PACKET_ptr packet_ptr, UINT status)
0481 {
0482   UINT version = getPacketHdrVersion (packet_ptr);
0483   if (version != valueFailure)
0484     return setPacketStatusV[version](packet_ptr, status);
0485   else
0486     return logicFailure;
0487 }
0488
0489 LOGIC_ret setPacketErrorLength(PACKET_ptr packet_ptr, UINT errorLength)
0490 {
0491   UINT version = getPacketHdrVersion (packet_ptr);
0492   if (version != valueFailure)
0493     return setPacketErrorLengthV[version](packet_ptr, errorLength);
0494   else
0495     return logicFailure;
0496 }
0497
0498 LOGIC_ret setPacketDataDescrLength(PACKET_ptr packet_ptr, UINT descrLength)
0499 {
0500   UINT version = getPacketHdrVersion (packet_ptr);
0501   if (version != valueFailure)
0502     return setPacketDataDescrLengthV[version](packet_ptr, descrLength);
0503   else
0504     return logicFailure;
0505 }
0506
0507 PTR_ret findPacketDataEnd (PACKET_ptr packet_ptr)
0508 {
0509   UINT version = getPacketHdrVersion (packet_ptr);
0510   if (version != valueFailure)
0511     return findPacketDataEndV[version](packet_ptr);
0512   else
0513     return ptrFailure;
0514 }
0515
0516 PTR_ret findPacketDebugStart (PACKET_ptr packet_ptr)
0517 {
0518   UINT version = getPacketHdrVersion (packet_ptr);
0519   if (version != valueFailure)
0520     return findPacketDebugStartV[version](packet_ptr);
0521   else
0522     return ptrFailure;
0523 }
0524
0525 PTR_ret findPacketErrorStart (PACKET_ptr packet_ptr)
0526 {
0527   UINT version = getPacketHdrVersion (packet_ptr);
0528   if (version != valueFailure)
0529     return (*findPacketErrorStartV[version])(packet_ptr);
0530   else
0531     return ptrFailure;
0532 }
0533
0534 PTR_ret findPacketDataDescr (PACKET_ptr packet_ptr)
0535 {
0536   UINT version = getPacketHdrVersion (packet_ptr);
0537   if (version != valueFailure)
0538     return (*findPacketDataDescrV[version])(packet_ptr);
0539   else
0540     return ptrFailure;
0541 }
0542
0543
0544 LOGIC_ret validPacketHdr (PACKET_ptr packet_ptr)
0545 {
0546   UINT version = getPacketHdrVersion (packet_ptr);
0547   if ( (version > 0) && (version < NUM_PACKET_VERSIONS) )
0548     return validPacketHdrV[version](packet_ptr);
0549   else
0550     return logicFailure;
0551 }
0552
0553 LOGIC_ret emptyPacket (PACKET_ptr packet_ptr)
0554 {
0555   UINT version = getPacketHdrVersion (packet_ptr);
0556   if (version != valueFailure)
0557     return emptyPacketV[version](packet_ptr);
0558   else
0559     return logicFailure;
0560 }
0561
0562 VALUE_ret adjustPacketDataLength(PACKET_ptr packet_ptr, int addDwords)
0563 {
0564   UINT version = getPacketHdrVersion (packet_ptr);
0565   if (version != valueFailure)
0566     return adjustPacketDataLengthV[version](packet_ptr, addDwords);
0567   else
0568     return valueFailure;
0569 }
0570
0571 VALUE_ret adjustPacketDebugLength(PACKET_ptr packet_ptr, int addLength)
0572 {
0573   UINT version = getPacketHdrVersion (packet_ptr);
0574   if (version != valueFailure)
0575     return adjustPacketDebugLengthV[version](packet_ptr, addLength);
0576   else
0577     return valueFailure;
0578 }
0579
0580 VALUE_ret adjustPacketErrorLength(PACKET_ptr packet_ptr, int addLength)
0581 {
0582   UINT version = getPacketHdrVersion (packet_ptr);
0583   if (version != valueFailure)
0584     return adjustPacketErrorLengthV[version](packet_ptr, addLength);
0585   else
0586     return valueFailure;
0587 }
0588
0589 #endif
0590
0591
0592
0593
0594
0595
0596
0597
0598
0599