online_distribution/newbasic/framePackets.C

0001 /*
0002 ** framePackets.C
0003 **
0004 ** Author: $Author: phnxbld $
0005 **   Date: $Date: 2009/08/19 12:30:51 $
0006 **
0007 ** $Log: framePackets.C,v $
0008 ** Revision 1.3  2009/08/19 12:30:51  phnxbld
0009 ** fix check on failure
0010 **
0011 ** Revision 1.2  2002/05/31 22:15:42  purschke
0012 ** mlp -- went through the insure report and tried to fix
0013 ** every little problem there is, unused variables, dead statements,
0014 ** all. It'll probably take another round to complete, but it should get
0015 ** rid of most warnings.
0016 **
0017 ** Revision 1.1.1.1  2000/07/21 01:51:13  purschke
0018 ** mlp -- adding the new automakified "basic" module to CVS.
0019 **
0020 **
0021 ** Revision 1.6  1998/12/23 20:34:57  markacs
0022 ** fixed findFramePacketId so it returns ptrFailure if called for an index of 0 in the case that there are no packets in the frame
0023 **
0024 ** Revision 1.5  1998/12/11 22:02:04  markacs
0025 ** (stephen markacs) adding log into cvs tags
0026 **
0027 */
0028 /*
0029 **  Routines that perform functions on packets with knowledge of the
0030 **    frame that the packets reside in.
0031 **
0032 **/
0033
0034 #include "framePackets.h"
0035 #include "Cframe.h"
0036 #include "Cpacket.h"
0037 #include "packetPublic.h"
0038 #include "framePublic.h"
0039 #include "frameRoutines.h"
0040 #include "packetRoutines.h"
0041 #include "formatError.h"
0042
0043
0044 PACKET_ptr appendEmptyFramePacket (FRAME_ptr frame_ptr, PHDWORD maxFrameLength, UINT packetId)
0045 {
0046   UINT extendDwords;
0047   UINT maxPacketLength;
0048   PACKET_ptr newPacket_ptr;
0049
0050   /*
0051   **  Check for valid frame header
0052   */
0053   if (!validFrameHdr (frame_ptr))
0054     return ptrFailure;
0055
0056   /*
0057   **  Now extend the frame to hold the new packet header
0058   */
0059   extendDwords = extendFrameData(frame_ptr, maxFrameLength, packetV1HdrLength);
0060   if (extendDwords == valueFailure) {
0061     setUserError(FORMAT_ERR_BUFFER_OVERFLOW, maxFrameLength);
0062     return ptrFailure;
0063   }
0064
0065   /*
0066   **  Get pointer to data section
0067   */
0068   newPacket_ptr = findFrameDataStart(frame_ptr);
0069
0070   /*
0071   **  Now make the empty packet
0072   */
0073   maxPacketLength = maxFrameLength - (UINT) (newPacket_ptr - frame_ptr);
0074   makeEmptyPacket(newPacket_ptr, maxPacketLength, packetId);
0075
0076   setPacketSuccess();
0077   return newPacket_ptr;
0078 }
0079
0080 LOGIC_ret isLastFramePacket (FRAME_ptr frame_ptr, PACKET_ptr packet_ptr)
0081 {
0082   PACKET_ptr lastPacket_ptr;
0083
0084   /*
0085   **  Check for valid frame, packet
0086   */
0087   if (!validFrameHdr (frame_ptr)) return FALSE;
0088   if (!validPacketHdr (frame_ptr)) return FALSE;
0089
0090   /*
0091   ** Now find the last packet
0092   */
0093   lastPacket_ptr = findLastFramePacket (frame_ptr);
0094
0095   return (lastPacket_ptr == packet_ptr);
0096
0097 }
0098
0099 /*
0100 **  Return the index'th packet in the frame where the indexing starts from 0.
0101 **    (i.e. findFramePacketIndex(frame_ptr, 0) returns the first packet)
0102 */
0103 PACKET_ptr findFramePacketIndex(FRAME_ptr frame_ptr, UINT index)
0104 {
0105   PACKET_ptr testPacket_ptr;
0106
0107   /*
0108   **  Check first for valid frame header
0109   */
0110   if (!validFrameHdr (frame_ptr)) {
0111     return ptrFailure;
0112   }
0113
0114   /*
0115   **  Point to first packet
0116   */
0117   testPacket_ptr = (PACKET_ptr) findFrameDataStart (frame_ptr);
0118
0119   if (index > 0) {
0120     UINT iPacket;
0121
0122     /*
0123     **  Loop the necessary number of times but check to make sure we have valid pointer
0124     */
0125     for (iPacket=0; iPacket<index ; iPacket++) {
0126       testPacket_ptr = findNextFramePacket (frame_ptr, testPacket_ptr);
0127       if (testPacket_ptr == ptrFailure) {
0128     return ptrFailure;
0129       }
0130     }
0131   }
0132   else  /* if index=0 make sure there's a packet there */
0133     {
0134       if (!validPacketHdr(testPacket_ptr)) return ptrFailure;
0135     }
0136
0137   /*
0138   **  If we get here we have the requested packet pointer
0139   */
0140   return testPacket_ptr;
0141 }
0142
0143 /*
0144 **  Return a pointer to the first packet in the frame
0145 */
0146 PACKET_ptr findFirstFramePacket(FRAME_ptr frame_ptr)
0147 {
0148   return findFramePacketIndex(frame_ptr, 0);
0149 }
0150
0151 /*
0152 **  Return a pointer to the first packet in the frame
0153 */
0154 PACKET_ptr findLastFramePacket(FRAME_ptr frame_ptr)
0155 {
0156   PACKET_ptr thisPacket_ptr, nextPacket_ptr;
0157
0158   /*
0159   **  Find the first packet
0160   */
0161   if (!(nextPacket_ptr = findFirstFramePacket (frame_ptr))) return ptrFailure;
0162
0163   /*
0164   **  Now iterate to the end
0165   */
0166   while (nextPacket_ptr != ptrFailure) {
0167     thisPacket_ptr = nextPacket_ptr;
0168     nextPacket_ptr = findNextFramePacket (frame_ptr, nextPacket_ptr);
0169   }
0170
0171   return thisPacket_ptr;
0172 }
0173
0174 /*
0175 **  findFramePacketID
0176 **
0177 **      Find a packet with a specified packet ID in a frame starting at the
0178 **        packet in the frame. If no packet with the ID is found ptrFailure is returned.
0179 **
0180 */
0181 PACKET_ptr findFramePacketId (FRAME_ptr frame_ptr, UINT packetId)
0182 {
0183   PACKET_ptr testPacket_ptr;
0184
0185   /*
0186   **  Check to make sure we have a good frame
0187   */
0188   if (!validFrameHdr (frame_ptr)) {
0189     return ptrFailure;
0190   }
0191
0192   /*
0193   **  Point to first packet
0194   */
0195   testPacket_ptr = (PACKET_ptr) findFrameDataStart (frame_ptr);
0196
0197   /*
0198   **  Now iterate until we fail to get enxt packet or find the one we want
0199   */
0200   while ( (testPacket_ptr != ptrFailure) && (getPacketId(testPacket_ptr) != packetId) )
0201     testPacket_ptr = findNextFramePacket (frame_ptr, testPacket_ptr);
0202
0203   return testPacket_ptr;
0204 }
0205
0206
0207 PACKET_ptr findNextFramePacketId (FRAME_ptr frame_ptr, PACKET_ptr previousPacket_ptr, UINT packetId)
0208 {
0209   /*
0210   **  BEWARE !!! No check on valid frame once we're past the first packet.
0211   */
0212
0213     /*
0214 **  Skip the "previous" packet
0215 */
0216   PACKET_ptr testPacket_ptr = findNextFramePacket(frame_ptr, previousPacket_ptr);
0217
0218   /*
0219     **  Now iterate until we fail to get enxt packet or find the one we want
0220     */
0221   while ( (testPacket_ptr != ptrFailure) && (getPacketId(testPacket_ptr) != packetId) )
0222     testPacket_ptr = findNextFramePacket (frame_ptr, testPacket_ptr);
0223
0224   return testPacket_ptr;
0225 }
0226
0227 /*
0228 **  Private routine to search for a packet in a unbroken data block of packets
0229 */
0230 PACKET_ptr findNextFramePacket (FRAME_ptr frame_ptr, PACKET_ptr currentPacket_ptr)
0231 {
0232   PACKET_ptr nextPacket_ptr;
0233
0234   /*
0235   ** Figure out where the frame ends
0236   */
0237   PHDWORD* frameDataStart_ptr = findFrameDataStart(frame_ptr);
0238   PHDWORD* frameDataEnd_ptr = findFrameDataEnd(frame_ptr);
0239
0240   /*
0241   **  Check for valid current packet pointer
0242   */
0243   if ((currentPacket_ptr < frameDataStart_ptr) || (currentPacket_ptr > frameDataEnd_ptr)) {
0244     return ptrFailure;
0245   }
0246
0247   /*
0248   **  Now skip past "current" packet
0249   */
0250   nextPacket_ptr = findPacketEnd(currentPacket_ptr) + 1;
0251
0252   if (nextPacket_ptr > frameDataEnd_ptr) return ptrFailure;
0253   else return nextPacket_ptr;
0254 }
0255
0256
0257 /*
0258 ** routine to find the number of packets in a frame
0259 */
0260 VALUE_ret frameNumPackets (FRAME_ptr frame_ptr)
0261 {
0262   UINT numPackets = 1;
0263   PACKET_ptr packet_ptr = findFirstFramePacket(frame_ptr);
0264   if (packet_ptr == ptrFailure) return 0;
0265   while ( (packet_ptr = findNextFramePacket(frame_ptr,packet_ptr)) != ptrFailure )
0266     numPackets++;
0267   return numPackets;
0268 }