Home | History | Annotate | Download | only in common_time 
      1 /*
      2  * Copyright (C) 2012 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 /*
     18  * A service that exchanges time synchronization information between
     19  * a master that defines a timeline and clients that follow the timeline.
     20  */
     21 
     22 #define LOG_TAG "common_time"
     23 #include <utils/Log.h>
     24 
     25 #include <arpa/inet.h>
     26 #include <stdint.h>
     27 
     28 #include "common_time_server_packets.h"
     29 
     30 namespace android {
     31 
     32 const uint32_t TimeServicePacketHeader::kMagic =
     33     (static_cast<uint32_t>('c') << 24) |
     34     (static_cast<uint32_t>('c') << 16) |
     35     (static_cast<uint32_t>('l') <<  8) |
     36      static_cast<uint32_t>('k');
     37 
     38 const uint16_t TimeServicePacketHeader::kCurVersion = 1;
     39 
     40 #define SERIALIZE_FIELD(field_name, type, converter)        \
     41     do {                                                    \
     42         if ((offset + sizeof(field_name)) > length)         \
     43             return -1;                                      \
     44         *((type*)(data + offset)) = converter(field_name);  \
     45         offset += sizeof(field_name);                       \
     46     } while (0)
     47 #define SERIALIZE_INT16(field_name) SERIALIZE_FIELD(field_name, int16_t, htons)
     48 #define SERIALIZE_INT32(field_name) SERIALIZE_FIELD(field_name, int32_t, htonl)
     49 #define SERIALIZE_INT64(field_name) SERIALIZE_FIELD(field_name, int64_t, htonq)
     50 
     51 #define DESERIALIZE_FIELD(field_name, type, converter)      \
     52     do {                                                    \
     53         if ((offset + sizeof(field_name)) > length)         \
     54             return -1;                                      \
     55         field_name = converter(*((type*)(data + offset)));  \
     56         offset += sizeof(field_name);                       \
     57     } while (0)
     58 #define DESERIALIZE_INT16(field_name) DESERIALIZE_FIELD(field_name, int16_t, ntohs)
     59 #define DESERIALIZE_INT32(field_name) DESERIALIZE_FIELD(field_name, int32_t, ntohl)
     60 #define DESERIALIZE_INT64(field_name) DESERIALIZE_FIELD(field_name, int64_t, ntohq)
     61 
     62 #define kDevicePriorityShift 56
     63 #define kDeviceIDMask ((static_cast<uint64_t>(1) << kDevicePriorityShift) - 1)
     64 
     65 inline uint64_t packDeviceID(uint64_t devID, uint8_t prio) {
     66     return (devID & kDeviceIDMask) |
     67            (static_cast<uint64_t>(prio) << kDevicePriorityShift);
     68 }
     69 
     70 inline uint64_t unpackDeviceID(uint64_t packed) {
     71     return (packed & kDeviceIDMask);
     72 }
     73 
     74 inline uint8_t unpackDevicePriority(uint64_t packed) {
     75     return static_cast<uint8_t>(packed >> kDevicePriorityShift);
     76 }
     77 
     78 ssize_t TimeServicePacketHeader::serializeHeader(uint8_t* data,
     79                                                  uint32_t length) {
     80     ssize_t offset = 0;
     81     int16_t pktType = static_cast<int16_t>(packetType);
     82     SERIALIZE_INT32(magic);
     83     SERIALIZE_INT16(version);
     84     SERIALIZE_INT16(pktType);
     85     SERIALIZE_INT64(timelineID);
     86     SERIALIZE_INT64(syncGroupID);
     87     return offset;
     88 }
     89 
     90 ssize_t TimeServicePacketHeader::deserializeHeader(const uint8_t* data,
     91                                                    uint32_t length) {
     92     ssize_t offset = 0;
     93     int16_t tmp;
     94     DESERIALIZE_INT32(magic);
     95     DESERIALIZE_INT16(version);
     96     DESERIALIZE_INT16(tmp);
     97     DESERIALIZE_INT64(timelineID);
     98     DESERIALIZE_INT64(syncGroupID);
     99     packetType = static_cast<TimeServicePacketType>(tmp);
    100     return offset;
    101 }
    102 
    103 ssize_t TimeServicePacketHeader::serializePacket(uint8_t* data,
    104                                                  uint32_t length) {
    105     ssize_t ret, tmp;
    106 
    107     ret = serializeHeader(data, length);
    108     if (ret < 0)
    109         return ret;
    110 
    111     data += ret;
    112     length -= ret;
    113 
    114     switch (packetType) {
    115         case TIME_PACKET_WHO_IS_MASTER_REQUEST:
    116             tmp =((WhoIsMasterRequestPacket*)(this))->serializePacket(data,
    117                                                                       length);
    118             break;
    119         case TIME_PACKET_WHO_IS_MASTER_RESPONSE:
    120             tmp =((WhoIsMasterResponsePacket*)(this))->serializePacket(data,
    121                                                                        length);
    122             break;
    123         case TIME_PACKET_SYNC_REQUEST:
    124             tmp =((SyncRequestPacket*)(this))->serializePacket(data, length);
    125             break;
    126         case TIME_PACKET_SYNC_RESPONSE:
    127             tmp =((SyncResponsePacket*)(this))->serializePacket(data, length);
    128             break;
    129         case TIME_PACKET_MASTER_ANNOUNCEMENT:
    130             tmp =((MasterAnnouncementPacket*)(this))->serializePacket(data,
    131                                                                       length);
    132             break;
    133         default:
    134             return -1;
    135     }
    136 
    137     if (tmp < 0)
    138         return tmp;
    139 
    140     return ret + tmp;
    141 }
    142 
    143 ssize_t UniversalTimeServicePacket::deserializePacket(
    144         const uint8_t* data,
    145         uint32_t length,
    146         uint64_t expectedSyncGroupID) {
    147     ssize_t ret;
    148     TimeServicePacketHeader* header;
    149     if (length < 8)
    150         return -1;
    151 
    152     packetType = ntohs(*((uint16_t*)(data + 6)));
    153     switch (packetType) {
    154         case TIME_PACKET_WHO_IS_MASTER_REQUEST:
    155             ret = p.who_is_master_request.deserializePacket(data, length);
    156             header = &p.who_is_master_request;
    157             break;
    158         case TIME_PACKET_WHO_IS_MASTER_RESPONSE:
    159             ret = p.who_is_master_response.deserializePacket(data, length);
    160             header = &p.who_is_master_response;
    161             break;
    162         case TIME_PACKET_SYNC_REQUEST:
    163             ret = p.sync_request.deserializePacket(data, length);
    164             header = &p.sync_request;
    165             break;
    166         case TIME_PACKET_SYNC_RESPONSE:
    167             ret = p.sync_response.deserializePacket(data, length);
    168             header = &p.sync_response;
    169             break;
    170         case TIME_PACKET_MASTER_ANNOUNCEMENT:
    171             ret = p.master_announcement.deserializePacket(data, length);
    172             header = &p.master_announcement;
    173             break;
    174         default:
    175             return -1;
    176     }
    177 
    178     if ((ret >= 0) && !header->checkPacket(expectedSyncGroupID))
    179         ret = -1;
    180 
    181     return ret;
    182 }
    183 
    184 ssize_t WhoIsMasterRequestPacket::serializePacket(uint8_t* data,
    185                                                   uint32_t length) {
    186     ssize_t offset = serializeHeader(data, length);
    187     if (offset > 0) {
    188         uint64_t packed = packDeviceID(senderDeviceID, senderDevicePriority);
    189         SERIALIZE_INT64(packed);
    190     }
    191     return offset;
    192 }
    193 
    194 ssize_t WhoIsMasterRequestPacket::deserializePacket(const uint8_t* data,
    195                                                     uint32_t length) {
    196     ssize_t offset = deserializeHeader(data, length);
    197     if (offset > 0) {
    198         uint64_t packed;
    199         DESERIALIZE_INT64(packed);
    200         senderDeviceID       = unpackDeviceID(packed);
    201         senderDevicePriority = unpackDevicePriority(packed);
    202     }
    203     return offset;
    204 }
    205 
    206 ssize_t WhoIsMasterResponsePacket::serializePacket(uint8_t* data,
    207                                                    uint32_t length) {
    208     ssize_t offset = serializeHeader(data, length);
    209     if (offset > 0) {
    210         uint64_t packed = packDeviceID(deviceID, devicePriority);
    211         SERIALIZE_INT64(packed);
    212     }
    213     return offset;
    214 }
    215 
    216 ssize_t WhoIsMasterResponsePacket::deserializePacket(const uint8_t* data,
    217                                                      uint32_t length) {
    218     ssize_t offset = deserializeHeader(data, length);
    219     if (offset > 0) {
    220         uint64_t packed;
    221         DESERIALIZE_INT64(packed);
    222         deviceID       = unpackDeviceID(packed);
    223         devicePriority = unpackDevicePriority(packed);
    224     }
    225     return offset;
    226 }
    227 
    228 ssize_t SyncRequestPacket::serializePacket(uint8_t* data,
    229                                            uint32_t length) {
    230     ssize_t offset = serializeHeader(data, length);
    231     if (offset > 0) {
    232         SERIALIZE_INT64(clientTxLocalTime);
    233     }
    234     return offset;
    235 }
    236 
    237 ssize_t SyncRequestPacket::deserializePacket(const uint8_t* data,
    238                                              uint32_t length) {
    239     ssize_t offset = deserializeHeader(data, length);
    240     if (offset > 0) {
    241         DESERIALIZE_INT64(clientTxLocalTime);
    242     }
    243     return offset;
    244 }
    245 
    246 ssize_t SyncResponsePacket::serializePacket(uint8_t* data,
    247                                             uint32_t length) {
    248     ssize_t offset = serializeHeader(data, length);
    249     if (offset > 0) {
    250         SERIALIZE_INT64(clientTxLocalTime);
    251         SERIALIZE_INT64(masterRxCommonTime);
    252         SERIALIZE_INT64(masterTxCommonTime);
    253         SERIALIZE_INT32(nak);
    254     }
    255     return offset;
    256 }
    257 
    258 ssize_t SyncResponsePacket::deserializePacket(const uint8_t* data,
    259                                               uint32_t length) {
    260     ssize_t offset = deserializeHeader(data, length);
    261     if (offset > 0) {
    262         DESERIALIZE_INT64(clientTxLocalTime);
    263         DESERIALIZE_INT64(masterRxCommonTime);
    264         DESERIALIZE_INT64(masterTxCommonTime);
    265         DESERIALIZE_INT32(nak);
    266     }
    267     return offset;
    268 }
    269 
    270 ssize_t MasterAnnouncementPacket::serializePacket(uint8_t* data,
    271                                                   uint32_t length) {
    272     ssize_t offset = serializeHeader(data, length);
    273     if (offset > 0) {
    274         uint64_t packed = packDeviceID(deviceID, devicePriority);
    275         SERIALIZE_INT64(packed);
    276     }
    277     return offset;
    278 }
    279 
    280 ssize_t MasterAnnouncementPacket::deserializePacket(const uint8_t* data,
    281                                                     uint32_t length) {
    282     ssize_t offset = deserializeHeader(data, length);
    283     if (offset > 0) {
    284         uint64_t packed;
    285         DESERIALIZE_INT64(packed);
    286         deviceID       = unpackDeviceID(packed);
    287         devicePriority = unpackDevicePriority(packed);
    288     }
    289     return offset;
    290 }
    291 
    292 }  // namespace android
    293 
    294