LEFT | RIGHT |
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ | 1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ |
2 /* | 2 /* |
3 * Copyright (c) 2006,2007 INRIA | 3 * Copyright (c) 2006,2007 INRIA |
4 * | 4 * |
5 * This program is free software; you can redistribute it and/or modify | 5 * This program is free software; you can redistribute it and/or modify |
6 * it under the terms of the GNU General Public License version 2 as | 6 * it under the terms of the GNU General Public License version 2 as |
7 * published by the Free Software Foundation; | 7 * published by the Free Software Foundation; |
8 * | 8 * |
9 * This program is distributed in the hope that it will be useful, | 9 * This program is distributed in the hope that it will be useful, |
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of | 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
(...skipping 1037 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1048 } | 1048 } |
1049 m_offset += extraItem.fragmentEnd - extraItem.fragmentStart; | 1049 m_offset += extraItem.fragmentEnd - extraItem.fragmentStart; |
1050 return item; | 1050 return item; |
1051 } | 1051 } |
1052 | 1052 |
1053 uint32_t· | 1053 uint32_t· |
1054 PacketMetadata::GetSerializedSize (void) const | 1054 PacketMetadata::GetSerializedSize (void) const |
1055 { | 1055 { |
1056 NS_LOG_FUNCTION (this); | 1056 NS_LOG_FUNCTION (this); |
1057 uint32_t totalSize = 0; | 1057 uint32_t totalSize = 0; |
1058 totalSize += 4; | 1058 |
| 1059 // add 8 bytes for the packet uid |
| 1060 totalSize += 8; |
| 1061 |
| 1062 // if packet-metadata not enabled, total size |
| 1063 // is simply 4-bytes for itself plus 8-bytes· |
| 1064 // for packet uid |
1059 if (!m_enable) | 1065 if (!m_enable) |
1060 { | 1066 { |
1061 return totalSize; | 1067 return totalSize; |
1062 } | 1068 } |
| 1069 |
1063 struct PacketMetadata::SmallItem item; | 1070 struct PacketMetadata::SmallItem item; |
1064 struct PacketMetadata::ExtraItem extraItem; | 1071 struct PacketMetadata::ExtraItem extraItem; |
1065 uint32_t current = m_head; | 1072 uint32_t current = m_head; |
1066 while (current != 0xffff) | 1073 while (current != 0xffff) |
1067 { | 1074 { |
1068 ReadItems (current, &item, &extraItem); | 1075 ReadItems (current, &item, &extraItem); |
1069 uint32_t uid = (item.typeUid & 0xfffffffe) >> 1; | 1076 uint32_t uid = (item.typeUid & 0xfffffffe) >> 1; |
1070 if (uid == 0) | 1077 if (uid == 0) |
1071 { | 1078 { |
1072 totalSize += 4; | 1079 totalSize += 4; |
1073 } | 1080 } |
1074 else | 1081 else |
1075 { | 1082 { |
1076 TypeId tid; | 1083 TypeId tid; |
1077 tid.SetUid (uid); | 1084 tid.SetUid (uid); |
1078 totalSize += 4 + tid.GetName ().size (); | 1085 totalSize += 4 + tid.GetName ().size (); |
1079 } | 1086 } |
1080 totalSize += 1 + 4 + 2 + 4 + 4 + 4; | 1087 totalSize += 1 + 4 + 2 + 4 + 4 + 8; |
1081 if (current == m_tail) | 1088 if (current == m_tail) |
1082 { | 1089 { |
1083 break; | 1090 break; |
1084 } | 1091 } |
1085 NS_ASSERT (current != item.next); | 1092 NS_ASSERT (current != item.next); |
1086 current = item.next; | 1093 current = item.next; |
1087 } | 1094 } |
1088 return totalSize; | 1095 return totalSize; |
1089 } | 1096 } |
1090 void | 1097 |
1091 PacketMetadata::Serialize (Buffer::Iterator i, uint32_t size) const | 1098 uint32_t |
| 1099 PacketMetadata::Serialize (uint8_t* buffer, uint32_t maxSize) const |
1092 { | 1100 { |
1093 NS_LOG_FUNCTION (this); | 1101 NS_LOG_FUNCTION (this); |
1094 uint32_t bytesWritten = 0; | 1102 uint8_t* start = buffer; |
1095 i.WriteU32 (size); | 1103 |
1096 bytesWritten += 4; | 1104 buffer = AddToRawU64 (m_packetUid, start, buffer, maxSize); |
| 1105 if (buffer == 0)· |
| 1106 { |
| 1107 return 0; |
| 1108 } |
| 1109 ·· |
1097 struct PacketMetadata::SmallItem item; | 1110 struct PacketMetadata::SmallItem item; |
1098 struct PacketMetadata::ExtraItem extraItem; | 1111 struct PacketMetadata::ExtraItem extraItem; |
1099 uint32_t current = m_head; | 1112 uint32_t current = m_head; |
1100 while (current != 0xffff) | 1113 while (current != 0xffff) |
1101 { | 1114 { |
1102 ReadItems (current, &item, &extraItem); | 1115 ReadItems (current, &item, &extraItem); |
1103 NS_LOG_LOGIC ("bytesWritten=" << bytesWritten << ", typeUid="<< | 1116 NS_LOG_LOGIC ("bytesWritten=" << (uint32_t)(buffer - start) << ", typeUid=
"<< |
1104 item.typeUid << ", size="<<item.size<<", chunkUid="<<item.chunkUid<< | 1117 item.typeUid << ", size="<<item.size<<", chunkUid="<<item.chunkUid<< |
1105 ", fragmentStart="<<extraItem.fragmentStart<<", fragmentEnd="<< | 1118 ", fragmentStart="<<extraItem.fragmentStart<<", fragmentEnd="<< |
1106 extraItem.fragmentEnd<< ", packetUid="<<extraItem.packetUid); | 1119 extraItem.fragmentEnd<< ", packetUid="<<extraItem.packetUid); |
| 1120 |
1107 uint32_t uid = (item.typeUid & 0xfffffffe) >> 1; | 1121 uint32_t uid = (item.typeUid & 0xfffffffe) >> 1; |
1108 if (uid != 0) | 1122 if (uid != 0) |
1109 { | 1123 { |
1110 TypeId tid; | 1124 TypeId tid; |
1111 tid.SetUid (uid); | 1125 tid.SetUid (uid); |
1112 std::string uidString = tid.GetName (); | 1126 std::string uidString = tid.GetName (); |
1113 i.WriteU32 (uidString.size ()); | 1127 uint32_t uidStringSize = uidString.size (); |
1114 bytesWritten += 4; | 1128 buffer = AddToRawU32 (uidStringSize, start, buffer, maxSize); |
1115 i.Write ((uint8_t *)uidString.c_str (), uidString.size ()); | 1129 if (buffer == 0)· |
1116 bytesWritten += uidString.size (); | 1130 { |
| 1131 return 0; |
| 1132 } |
| 1133 buffer = AddToRaw ((uint8_t *)uidString.c_str (),· |
| 1134 uidStringSize, start, buffer, maxSize); |
| 1135 if (buffer == 0)· |
| 1136 { |
| 1137 return 0; |
| 1138 } |
1117 } | 1139 } |
1118 else | 1140 else |
1119 { | 1141 { |
1120 i.WriteU32 (0); | 1142 buffer = AddToRawU32 (0, start, buffer, maxSize); |
1121 bytesWritten += 4; | 1143 if (buffer == 0)· |
1122 } | 1144 { |
| 1145 return 0; |
| 1146 } |
| 1147 } |
| 1148 |
1123 uint8_t isBig = item.typeUid & 0x1; | 1149 uint8_t isBig = item.typeUid & 0x1; |
1124 i.WriteU8 (isBig); | 1150 buffer = AddToRawU8 (isBig, start, buffer, maxSize); |
1125 bytesWritten += 1; | 1151 if (buffer == 0)· |
1126 i.WriteU32 (item.size); | 1152 { |
1127 bytesWritten += 4; | 1153 return 0; |
1128 i.WriteU16 (item.chunkUid); | 1154 } |
1129 bytesWritten += 2; | 1155 |
1130 i.WriteU32 (extraItem.fragmentStart); | 1156 buffer = AddToRawU32 (item.size, start, buffer, maxSize); |
1131 bytesWritten += 4; | 1157 if (buffer == 0)· |
1132 i.WriteU32 (extraItem.fragmentEnd); | 1158 { |
1133 bytesWritten += 4; | 1159 return 0; |
1134 i.WriteU32 (extraItem.packetUid); | 1160 } |
1135 bytesWritten += 4; | 1161 |
| 1162 buffer = AddToRawU16 (item.chunkUid, start, buffer, maxSize); |
| 1163 if (buffer == 0)· |
| 1164 { |
| 1165 return 0; |
| 1166 } |
| 1167 |
| 1168 buffer = AddToRawU32 (extraItem.fragmentStart, start, buffer, maxSize); |
| 1169 if (buffer == 0)· |
| 1170 { |
| 1171 return 0; |
| 1172 } |
| 1173 |
| 1174 buffer = AddToRawU32 (extraItem.fragmentEnd, start, buffer, maxSize); |
| 1175 if (buffer == 0)· |
| 1176 { |
| 1177 return 0; |
| 1178 } |
| 1179 |
| 1180 buffer = AddToRawU64 (extraItem.packetUid, start, buffer, maxSize); |
| 1181 if (buffer == 0)· |
| 1182 { |
| 1183 return 0; |
| 1184 } |
| 1185 |
1136 if (current == m_tail) | 1186 if (current == m_tail) |
1137 { | 1187 { |
1138 break; | 1188 break; |
1139 } | 1189 } |
1140 ······ | 1190 ······ |
1141 NS_ASSERT (current != item.next); | 1191 NS_ASSERT (current != item.next); |
1142 current = item.next; | 1192 current = item.next; |
1143 } | 1193 } |
1144 NS_ASSERT (bytesWritten == size); | 1194 |
1145 } | 1195 NS_ASSERT ((uint32_t)(buffer - start) == maxSize); |
| 1196 return 1; |
| 1197 } |
| 1198 |
1146 uint32_t· | 1199 uint32_t· |
1147 PacketMetadata::Deserialize (Buffer::Iterator i) | 1200 PacketMetadata::Deserialize (uint8_t* buffer, uint32_t size) |
1148 { | 1201 { |
1149 NS_LOG_FUNCTION (this); | 1202 NS_LOG_FUNCTION (this); |
| 1203 uint8_t* start = buffer; |
| 1204 uint32_t desSize = size - 4; |
| 1205 |
| 1206 buffer = ReadFromRawU64 (m_packetUid, start, buffer, size); |
| 1207 desSize -= 8; |
| 1208 |
1150 struct PacketMetadata::SmallItem item; | 1209 struct PacketMetadata::SmallItem item; |
1151 struct PacketMetadata::ExtraItem extraItem; | 1210 struct PacketMetadata::ExtraItem extraItem; |
1152 uint32_t totalSize = i.ReadU32 (); | 1211 while (desSize > 0) |
1153 uint32_t size = totalSize; | 1212 { |
1154 size -= 4; | 1213 uint32_t uidStringSize = 0; |
1155 while (size > 0) | 1214 buffer = ReadFromRawU32 (uidStringSize, start, buffer, size); |
1156 { | 1215 desSize -= 4; |
1157 uint32_t uidStringSize = i.ReadU32 (); | |
1158 size -= 4; | |
1159 uint32_t uid; | 1216 uint32_t uid; |
1160 if (uidStringSize == 0) | 1217 if (uidStringSize == 0) |
1161 { | 1218 { |
1162 // uid zero for payload. | 1219 // uid zero for payload. |
1163 uid = 0; | 1220 uid = 0; |
1164 } | 1221 } |
1165 else | 1222 else |
1166 { | 1223 { |
1167 std::string uidString; | 1224 std::string uidString; |
1168 for (uint32_t j = 0; j < uidStringSize; j++) | 1225 for (uint32_t j = 0; j < uidStringSize; j++) |
1169 { | 1226 { |
1170 uidString.push_back (i.ReadU8 ()); | 1227 uint8_t ch = 0; |
1171 size --; | 1228 buffer = ReadFromRawU8 (ch, start, buffer, size); |
| 1229 uidString.push_back (ch); |
| 1230 desSize --; |
1172 } | 1231 } |
1173 TypeId tid = TypeId::LookupByName (uidString); | 1232 TypeId tid = TypeId::LookupByName (uidString); |
1174 uid = tid.GetUid (); | 1233 uid = tid.GetUid (); |
1175 } | 1234 } |
1176 uint8_t isBig = i.ReadU8 (); | 1235 uint8_t isBig = 0; |
1177 size --; | 1236 buffer = ReadFromRawU8 (isBig, start, buffer, size); |
| 1237 desSize --; |
1178 item.typeUid = (uid << 1) | isBig; | 1238 item.typeUid = (uid << 1) | isBig; |
1179 item.size = i.ReadU32 (); | 1239 buffer = ReadFromRawU32 (item.size, start, buffer, size); |
1180 size -= 4; | 1240 desSize -= 4; |
1181 item.chunkUid = i.ReadU16 (); | 1241 buffer = ReadFromRawU16 (item.chunkUid, start, buffer, size); |
1182 size -= 2; | 1242 desSize -= 2; |
1183 extraItem.fragmentStart = i.ReadU32 (); | 1243 buffer = ReadFromRawU32 (extraItem.fragmentStart, start, buffer, size); |
1184 size -= 4; | 1244 desSize -= 4; |
1185 extraItem.fragmentEnd = i.ReadU32 (); | 1245 buffer = ReadFromRawU32 (extraItem.fragmentEnd, start, buffer, size); |
1186 size -= 4; | 1246 desSize -= 4; |
1187 extraItem.packetUid = i.ReadU32 (); | 1247 buffer = ReadFromRawU64 (extraItem.packetUid, start, buffer, size); |
1188 size -= 4; | 1248 desSize -= 8; |
1189 NS_LOG_LOGIC ("size=" << size << ", typeUid="<<item.typeUid << | 1249 NS_LOG_LOGIC ("size=" << size << ", typeUid="<<item.typeUid << |
1190 ", size="<<item.size<<", chunkUid="<<item.chunkUid<< | 1250 ", size="<<item.size<<", chunkUid="<<item.chunkUid<< |
1191 ", fragmentStart="<<extraItem.fragmentStart<<", fragmentEnd="<< | 1251 ", fragmentStart="<<extraItem.fragmentStart<<", fragmentEnd="<< |
1192 extraItem.fragmentEnd<< ", packetUid="<<extraItem.packetUid); | 1252 extraItem.fragmentEnd<< ", packetUid="<<extraItem.packetUid); |
1193 uint32_t tmp = AddBig (0xffff, m_tail, &item, &extraItem); | 1253 uint32_t tmp = AddBig (0xffff, m_tail, &item, &extraItem); |
1194 UpdateTail (tmp); | 1254 UpdateTail (tmp); |
1195 } | 1255 } |
1196 NS_ASSERT (size == 0); | 1256 NS_ASSERT (desSize == 0); |
1197 return totalSize; | 1257 return (desSize !=0) ? 0 : 1; |
1198 } | 1258 } |
1199 | 1259 |
1200 // Serialization to raw uint8_t* buffer | 1260 uint8_t*· |
1201 // Used by MPI packet serialization | 1261 PacketMetadata::AddToRawU8 (const uint8_t& data, |
1202 uint32_t | 1262 uint8_t* start, |
1203 PacketMetadata::Serialize (uint8_t* i, uint32_t maxSize) const | 1263 uint8_t* current, |
1204 { | 1264 uint32_t maxSize) |
1205 NS_LOG_FUNCTION (this); | 1265 { |
1206 uint32_t bytesWritten = 0; | 1266 // First check buffer overflow |
1207 uint8_t* start = i; | 1267 if ((uint32_t)((current + sizeof (uint8_t) - start)) > maxSize)· |
1208 i = AddToRaw (maxSize, start, i, maxSize); | 1268 { |
1209 if (!i) return 0; // Overflow | 1269 return 0; |
1210 bytesWritten += 4; | 1270 } |
| 1271 memcpy (current, &data, sizeof (uint8_t)); |
| 1272 return current + sizeof (uint8_t); |
| 1273 } |
| 1274 |
| 1275 uint8_t*· |
| 1276 PacketMetadata::AddToRawU16 (const uint16_t& data, |
| 1277 uint8_t* start, |
| 1278 uint8_t* current, |
| 1279 uint32_t maxSize) |
| 1280 { |
| 1281 // First check buffer overflow |
| 1282 if ((uint32_t)((current + sizeof (uint16_t) - start)) > maxSize)· |
| 1283 { |
| 1284 return 0; |
| 1285 } |
| 1286 memcpy (current, &data, sizeof (uint16_t)); |
| 1287 return current + sizeof (uint16_t); |
| 1288 } |
| 1289 |
| 1290 uint8_t*· |
| 1291 PacketMetadata::AddToRawU32 (const uint32_t& data, |
| 1292 uint8_t* start, |
| 1293 uint8_t* current, |
| 1294 uint32_t maxSize) |
| 1295 { |
| 1296 // First check buffer overflow |
| 1297 if ((uint32_t)((current + sizeof (uint32_t) - start)) > maxSize)· |
| 1298 { |
| 1299 return 0; |
| 1300 } |
| 1301 memcpy (current, &data, sizeof (uint32_t)); |
| 1302 return current + sizeof (uint32_t); |
| 1303 } |
| 1304 |
| 1305 uint8_t*· |
| 1306 PacketMetadata::AddToRawU64 (const uint64_t& data, |
| 1307 uint8_t* start, |
| 1308 uint8_t* current, |
| 1309 uint32_t maxSize) |
| 1310 { |
| 1311 // First check buffer overflow |
| 1312 if ((uint32_t)((current + sizeof (uint64_t) - start)) > maxSize)· |
| 1313 { |
| 1314 return 0; |
| 1315 } |
| 1316 memcpy (current, &data, sizeof (uint64_t)); |
| 1317 return current + sizeof (uint64_t); |
| 1318 } |
1211 ·· | 1319 ·· |
1212 struct PacketMetadata::SmallItem item; | 1320 uint8_t*· |
1213 struct PacketMetadata::ExtraItem extraItem; | 1321 PacketMetadata::AddToRaw (const uint8_t* data, |
1214 uint32_t current = m_head; | 1322 uint32_t dataSize, |
1215 while (current != 0xffff) | 1323 uint8_t* start, |
1216 { | 1324 uint8_t* current, |
1217 ReadItems (current, &item, &extraItem); | 1325 uint32_t maxSize) |
1218 NS_LOG_LOGIC ("bytesWritten=" << bytesWritten << ", typeUid="<< | 1326 {· |
1219 item.typeUid << ", size="<<item.size<<", chunkUid="<<item.chunkUid<< | 1327 // First check buffer overflow |
1220 ", fragmentStart="<<extraItem.fragmentStart<<", fragmentEnd="<< | 1328 if ((uint32_t)((current + dataSize - start)) > maxSize)· |
1221 extraItem.fragmentEnd<< ", packetUid="<<extraItem.packetUid); | 1329 { |
1222 uint32_t uid = (item.typeUid & 0xfffffffe) >> 1; | 1330 return 0; |
1223 if (uid != 0) | 1331 } |
1224 { | 1332 memcpy (current, data, dataSize); |
1225 TypeId tid; | 1333 return current + dataSize; |
1226 tid.SetUid (uid); | 1334 } |
1227 std::string uidString = tid.GetName (); | 1335 ·· |
1228 i = AddToRaw (uidString.size (), start, i, maxSize); | 1336 uint8_t*· |
1229 if (!i) return 0; | 1337 PacketMetadata::ReadFromRawU8 (uint8_t& data, |
1230 bytesWritten += 4; | 1338 uint8_t* start, |
1231 i = AddToRaw (uidString.c_str (), uidString.size (), start, i, maxSize
); | 1339 uint8_t* current, |
1232 if (!i) return 0; | 1340 uint32_t maxSize) |
1233 bytesWritten += uidString.size (); | 1341 {· |
1234 } | 1342 // First check buffer underflow |
1235 else | 1343 if ((uint32_t)((current + sizeof (uint8_t) - start)) > maxSize)· |
1236 { | 1344 { |
1237 i = AddToRaw (0, start, i, maxSize); | 1345 return 0; |
1238 if (!i) return 0; // Overflow | 1346 } |
1239 bytesWritten += 4; | 1347 memcpy(&data, current, sizeof (uint8_t)); |
1240 } | 1348 return current + sizeof (uint8_t); |
1241 uint8_t isBig = item.typeUid & 0x1; | 1349 } |
1242 i = AddToRaw (isBig, start, i, maxSize); | 1350 |
1243 if (!i) return 0; // Overflow | 1351 uint8_t*· |
1244 bytesWritten += 4; | 1352 PacketMetadata::ReadFromRawU16 (uint16_t& data, |
1245 i = AddToRaw (item.size, start, i, maxSize); | 1353 uint8_t* start, |
1246 if (!i) return 0; // Overflow | 1354 uint8_t* current, |
1247 bytesWritten += 4; | 1355 uint32_t maxSize) |
1248 i = AddToRaw (item.chunkUid, start, i, maxSize); | 1356 {· |
1249 if (!i) return 0; // Overflow | 1357 // First check buffer underflow |
1250 bytesWritten += 4; | 1358 if ((uint32_t)((current + sizeof (uint16_t) - start)) > maxSize)· |
1251 i = AddToRaw (extraItem.fragmentStart, start, i, maxSize); | 1359 { |
1252 if (!i) return 0; // Overflow | 1360 return 0; |
1253 bytesWritten += 4; | 1361 } |
1254 i = AddToRaw (extraItem.fragmentEnd, start, i, maxSize); | 1362 memcpy(&data, current, sizeof (uint16_t)); |
1255 if (!i) return 0; // Overflow | 1363 return current + sizeof (uint16_t); |
1256 bytesWritten += 4; | 1364 } |
1257 i = AddToRaw (extraItem.packetUid, start, i, maxSize); | 1365 |
1258 if (!i) return 0; // Overflow | 1366 uint8_t*· |
1259 bytesWritten += 4; | 1367 PacketMetadata::ReadFromRawU32 (uint32_t& data, |
1260 if (current == m_tail) | 1368 uint8_t* start, |
1261 { | 1369 uint8_t* current, |
1262 break; | 1370 uint32_t maxSize) |
1263 } | 1371 {· |
1264 ······ | 1372 // First check buffer underflow |
1265 NS_ASSERT (current != item.next); | 1373 if ((uint32_t)((current + sizeof (uint32_t) - start)) > maxSize)· |
1266 current = item.next; | 1374 { |
1267 } | 1375 return 0; |
1268 NS_ASSERT ((uint32_t)(i - start) == maxSize); | 1376 } |
1269 NS_ASSERT (bytesWritten == maxSize); | 1377 memcpy(&data, current, sizeof (uint32_t)); |
1270 return 1; | 1378 return current + sizeof (uint32_t); |
1271 } | 1379 } |
1272 | 1380 |
1273 uint32_t· | 1381 uint8_t*· |
1274 PacketMetadata::Deserialize (uint8_t* i, uint32_t expectedSize) | 1382 PacketMetadata::ReadFromRawU64 (uint64_t& data, |
1275 { | 1383 uint8_t* start, |
1276 NS_LOG_FUNCTION (this); | 1384 uint8_t* current, |
1277 uint8_t* start = i; | 1385 uint32_t maxSize) |
1278 struct PacketMetadata::SmallItem item; | 1386 {· |
1279 struct PacketMetadata::ExtraItem extraItem; | 1387 // First check buffer underflow |
1280 uint32_t totalSize = expectedSize; | 1388 if ((uint32_t)((current + sizeof (uint64_t) - start)) > maxSize)· |
1281 uint32_t size = totalSize - 4; | 1389 { |
1282 while (size > 0) | 1390 return 0; |
1283 { | 1391 } |
1284 uint32_t uidStringSize = 0; | 1392 memcpy(&data, current, sizeof (uint64_t)); |
1285 i = ReadFromRaw (uidStringSize, start, i, expectedSize); | 1393 return current + sizeof (uint64_t); |
1286 size -= 4; | |
1287 uint32_t uid; | |
1288 if (uidStringSize == 0) | |
1289 { | |
1290 // uid zero for payload. | |
1291 uid = 0; | |
1292 } | |
1293 else | |
1294 { | |
1295 std::string uidString; | |
1296 for (uint32_t j = 0; j < uidStringSize; j++) | |
1297 { | |
1298 uint8_t ch = 0; | |
1299 i = ReadFromRaw (ch, start, i, expectedSize); | |
1300 uidString.push_back (ch); | |
1301 size --; | |
1302 } | |
1303 TypeId tid = TypeId::LookupByName (uidString); | |
1304 uid = tid.GetUid (); | |
1305 } | |
1306 uint8_t isBig = 0; | |
1307 i = ReadFromRaw (isBig, start, i, expectedSize); | |
1308 size --; | |
1309 item.typeUid = (uid << 1) | isBig; | |
1310 i = ReadFromRaw (item.size, start, i, expectedSize); | |
1311 size -= 4; | |
1312 i = ReadFromRaw (item.chunkUid, start, i, expectedSize); | |
1313 size -= 2; | |
1314 i = ReadFromRaw (extraItem.fragmentStart, start, i, expectedSize); | |
1315 size -= 4; | |
1316 i = ReadFromRaw (extraItem.fragmentEnd, start, i, expectedSize); | |
1317 size -= 4; | |
1318 i = ReadFromRaw (extraItem.packetUid, start, i, expectedSize); | |
1319 size -= 4; | |
1320 NS_LOG_LOGIC ("size=" << size << ", typeUid="<<item.typeUid << | |
1321 ", size="<<item.size<<", chunkUid="<<item.chunkUid<< | |
1322 ", fragmentStart="<<extraItem.fragmentStart<<", fragmentEnd="<< | |
1323 extraItem.fragmentEnd<< ", packetUid="<<extraItem.packetUid); | |
1324 uint32_t tmp = AddBig (0xffff, m_tail, &item, &extraItem); | |
1325 UpdateTail (tmp); | |
1326 } | |
1327 NS_ASSERT (size == 0); | |
1328 return (size !=0) ? 0 : 1; | |
1329 } | 1394 } |
1330 | 1395 |
1331 | 1396 |
1332 } // namespace ns3 | 1397 } // namespace ns3 |
1333 | 1398 |
LEFT | RIGHT |