summaryrefslogtreecommitdiffstats
path: root/services/common_time/common_time_server_packets.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'services/common_time/common_time_server_packets.cpp')
-rw-r--r--services/common_time/common_time_server_packets.cpp293
1 files changed, 0 insertions, 293 deletions
diff --git a/services/common_time/common_time_server_packets.cpp b/services/common_time/common_time_server_packets.cpp
deleted file mode 100644
index 9833c37..0000000
--- a/services/common_time/common_time_server_packets.cpp
+++ /dev/null
@@ -1,293 +0,0 @@
-/*
- * Copyright (C) 2012 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/*
- * A service that exchanges time synchronization information between
- * a master that defines a timeline and clients that follow the timeline.
- */
-
-#define LOG_TAG "common_time"
-#include <utils/Log.h>
-
-#include <arpa/inet.h>
-#include <stdint.h>
-
-#include "common_time_server_packets.h"
-
-namespace android {
-
-const uint32_t TimeServicePacketHeader::kMagic =
- (static_cast<uint32_t>('c') << 24) |
- (static_cast<uint32_t>('c') << 16) |
- (static_cast<uint32_t>('l') << 8) |
- static_cast<uint32_t>('k');
-
-const uint16_t TimeServicePacketHeader::kCurVersion = 1;
-
-#define SERIALIZE_FIELD(field_name, type, converter) \
- do { \
- if ((offset + sizeof(field_name)) > length) \
- return -1; \
- *((type*)(data + offset)) = converter(field_name); \
- offset += sizeof(field_name); \
- } while (0)
-#define SERIALIZE_INT16(field_name) SERIALIZE_FIELD(field_name, int16_t, htons)
-#define SERIALIZE_INT32(field_name) SERIALIZE_FIELD(field_name, int32_t, htonl)
-#define SERIALIZE_INT64(field_name) SERIALIZE_FIELD(field_name, int64_t, htonq)
-
-#define DESERIALIZE_FIELD(field_name, type, converter) \
- do { \
- if ((offset + sizeof(field_name)) > length) \
- return -1; \
- field_name = converter(*((type*)(data + offset))); \
- offset += sizeof(field_name); \
- } while (0)
-#define DESERIALIZE_INT16(field_name) DESERIALIZE_FIELD(field_name, int16_t, ntohs)
-#define DESERIALIZE_INT32(field_name) DESERIALIZE_FIELD(field_name, int32_t, ntohl)
-#define DESERIALIZE_INT64(field_name) DESERIALIZE_FIELD(field_name, int64_t, ntohq)
-
-#define kDevicePriorityShift 56
-#define kDeviceIDMask ((static_cast<uint64_t>(1) << kDevicePriorityShift) - 1)
-
-inline uint64_t packDeviceID(uint64_t devID, uint8_t prio) {
- return (devID & kDeviceIDMask) |
- (static_cast<uint64_t>(prio) << kDevicePriorityShift);
-}
-
-inline uint64_t unpackDeviceID(uint64_t packed) {
- return (packed & kDeviceIDMask);
-}
-
-inline uint8_t unpackDevicePriority(uint64_t packed) {
- return static_cast<uint8_t>(packed >> kDevicePriorityShift);
-}
-
-ssize_t TimeServicePacketHeader::serializeHeader(uint8_t* data,
- uint32_t length) {
- ssize_t offset = 0;
- int16_t pktType = static_cast<int16_t>(packetType);
- SERIALIZE_INT32(magic);
- SERIALIZE_INT16(version);
- SERIALIZE_INT16(pktType);
- SERIALIZE_INT64(timelineID);
- SERIALIZE_INT64(syncGroupID);
- return offset;
-}
-
-ssize_t TimeServicePacketHeader::deserializeHeader(const uint8_t* data,
- uint32_t length) {
- ssize_t offset = 0;
- int16_t tmp;
- DESERIALIZE_INT32(magic);
- DESERIALIZE_INT16(version);
- DESERIALIZE_INT16(tmp);
- DESERIALIZE_INT64(timelineID);
- DESERIALIZE_INT64(syncGroupID);
- packetType = static_cast<TimeServicePacketType>(tmp);
- return offset;
-}
-
-ssize_t TimeServicePacketHeader::serializePacket(uint8_t* data,
- uint32_t length) {
- ssize_t ret, tmp;
-
- ret = serializeHeader(data, length);
- if (ret < 0)
- return ret;
-
- data += ret;
- length -= ret;
-
- switch (packetType) {
- case TIME_PACKET_WHO_IS_MASTER_REQUEST:
- tmp =((WhoIsMasterRequestPacket*)(this))->serializePacket(data,
- length);
- break;
- case TIME_PACKET_WHO_IS_MASTER_RESPONSE:
- tmp =((WhoIsMasterResponsePacket*)(this))->serializePacket(data,
- length);
- break;
- case TIME_PACKET_SYNC_REQUEST:
- tmp =((SyncRequestPacket*)(this))->serializePacket(data, length);
- break;
- case TIME_PACKET_SYNC_RESPONSE:
- tmp =((SyncResponsePacket*)(this))->serializePacket(data, length);
- break;
- case TIME_PACKET_MASTER_ANNOUNCEMENT:
- tmp =((MasterAnnouncementPacket*)(this))->serializePacket(data,
- length);
- break;
- default:
- return -1;
- }
-
- if (tmp < 0)
- return tmp;
-
- return ret + tmp;
-}
-
-ssize_t UniversalTimeServicePacket::deserializePacket(
- const uint8_t* data,
- uint32_t length,
- uint64_t expectedSyncGroupID) {
- ssize_t ret;
- TimeServicePacketHeader* header;
- if (length < 8)
- return -1;
-
- packetType = ntohs(*((uint16_t*)(data + 6)));
- switch (packetType) {
- case TIME_PACKET_WHO_IS_MASTER_REQUEST:
- ret = p.who_is_master_request.deserializePacket(data, length);
- header = &p.who_is_master_request;
- break;
- case TIME_PACKET_WHO_IS_MASTER_RESPONSE:
- ret = p.who_is_master_response.deserializePacket(data, length);
- header = &p.who_is_master_response;
- break;
- case TIME_PACKET_SYNC_REQUEST:
- ret = p.sync_request.deserializePacket(data, length);
- header = &p.sync_request;
- break;
- case TIME_PACKET_SYNC_RESPONSE:
- ret = p.sync_response.deserializePacket(data, length);
- header = &p.sync_response;
- break;
- case TIME_PACKET_MASTER_ANNOUNCEMENT:
- ret = p.master_announcement.deserializePacket(data, length);
- header = &p.master_announcement;
- break;
- default:
- return -1;
- }
-
- if ((ret >= 0) && !header->checkPacket(expectedSyncGroupID))
- ret = -1;
-
- return ret;
-}
-
-ssize_t WhoIsMasterRequestPacket::serializePacket(uint8_t* data,
- uint32_t length) {
- ssize_t offset = serializeHeader(data, length);
- if (offset > 0) {
- uint64_t packed = packDeviceID(senderDeviceID, senderDevicePriority);
- SERIALIZE_INT64(packed);
- }
- return offset;
-}
-
-ssize_t WhoIsMasterRequestPacket::deserializePacket(const uint8_t* data,
- uint32_t length) {
- ssize_t offset = deserializeHeader(data, length);
- if (offset > 0) {
- uint64_t packed;
- DESERIALIZE_INT64(packed);
- senderDeviceID = unpackDeviceID(packed);
- senderDevicePriority = unpackDevicePriority(packed);
- }
- return offset;
-}
-
-ssize_t WhoIsMasterResponsePacket::serializePacket(uint8_t* data,
- uint32_t length) {
- ssize_t offset = serializeHeader(data, length);
- if (offset > 0) {
- uint64_t packed = packDeviceID(deviceID, devicePriority);
- SERIALIZE_INT64(packed);
- }
- return offset;
-}
-
-ssize_t WhoIsMasterResponsePacket::deserializePacket(const uint8_t* data,
- uint32_t length) {
- ssize_t offset = deserializeHeader(data, length);
- if (offset > 0) {
- uint64_t packed;
- DESERIALIZE_INT64(packed);
- deviceID = unpackDeviceID(packed);
- devicePriority = unpackDevicePriority(packed);
- }
- return offset;
-}
-
-ssize_t SyncRequestPacket::serializePacket(uint8_t* data,
- uint32_t length) {
- ssize_t offset = serializeHeader(data, length);
- if (offset > 0) {
- SERIALIZE_INT64(clientTxLocalTime);
- }
- return offset;
-}
-
-ssize_t SyncRequestPacket::deserializePacket(const uint8_t* data,
- uint32_t length) {
- ssize_t offset = deserializeHeader(data, length);
- if (offset > 0) {
- DESERIALIZE_INT64(clientTxLocalTime);
- }
- return offset;
-}
-
-ssize_t SyncResponsePacket::serializePacket(uint8_t* data,
- uint32_t length) {
- ssize_t offset = serializeHeader(data, length);
- if (offset > 0) {
- SERIALIZE_INT64(clientTxLocalTime);
- SERIALIZE_INT64(masterRxCommonTime);
- SERIALIZE_INT64(masterTxCommonTime);
- SERIALIZE_INT32(nak);
- }
- return offset;
-}
-
-ssize_t SyncResponsePacket::deserializePacket(const uint8_t* data,
- uint32_t length) {
- ssize_t offset = deserializeHeader(data, length);
- if (offset > 0) {
- DESERIALIZE_INT64(clientTxLocalTime);
- DESERIALIZE_INT64(masterRxCommonTime);
- DESERIALIZE_INT64(masterTxCommonTime);
- DESERIALIZE_INT32(nak);
- }
- return offset;
-}
-
-ssize_t MasterAnnouncementPacket::serializePacket(uint8_t* data,
- uint32_t length) {
- ssize_t offset = serializeHeader(data, length);
- if (offset > 0) {
- uint64_t packed = packDeviceID(deviceID, devicePriority);
- SERIALIZE_INT64(packed);
- }
- return offset;
-}
-
-ssize_t MasterAnnouncementPacket::deserializePacket(const uint8_t* data,
- uint32_t length) {
- ssize_t offset = deserializeHeader(data, length);
- if (offset > 0) {
- uint64_t packed;
- DESERIALIZE_INT64(packed);
- deviceID = unpackDeviceID(packed);
- devicePriority = unpackDevicePriority(packed);
- }
- return offset;
-}
-
-} // namespace android
-