001/* 002 * Licensed to the Apache Software Foundation (ASF) under one 003 * or more contributor license agreements. See the NOTICE file 004 * distributed with this work for additional information 005 * regarding copyright ownership. The ASF licenses this file 006 * to you under the Apache License, Version 2.0 (the 007 * "License"); you may not use this file except in compliance 008 * with the License. You may obtain a copy of the License at 009 * 010 * http://www.apache.org/licenses/LICENSE-2.0 011 * 012 * Unless required by applicable law or agreed to in writing, 013 * software distributed under the License is distributed on an 014 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 015 * KIND, either express or implied. See the License for the 016 * specific language governing permissions and limitations 017 * under the License. 018 * 019 */ 020 021package org.apache.directory.server.ntp.io; 022 023 024import java.nio.ByteBuffer; 025import java.nio.charset.StandardCharsets; 026 027import org.apache.directory.server.ntp.messages.LeapIndicatorType; 028import org.apache.directory.server.ntp.messages.ModeType; 029import org.apache.directory.server.ntp.messages.NtpMessage; 030import org.apache.directory.server.ntp.messages.NtpMessageModifier; 031import org.apache.directory.server.ntp.messages.NtpTimeStamp; 032import org.apache.directory.server.ntp.messages.ReferenceIdentifier; 033import org.apache.directory.server.ntp.messages.StratumType; 034 035 036/** 037 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a> 038 */ 039public class NtpMessageDecoder 040{ 041 /** 042 * Decodes the {@link ByteBuffer} into an {@link NtpMessage}. 043 * 044 * @param request 045 * @return The {@link NtpMessage}. 046 */ 047 public NtpMessage decode( ByteBuffer request ) 048 { 049 NtpMessageModifier modifier = new NtpMessageModifier(); 050 051 byte header = request.get(); 052 modifier.setLeapIndicator( parseLeapIndicator( header ) ); 053 modifier.setVersionNumber( parseVersionNumber( header ) ); 054 modifier.setMode( parseMode( header ) ); 055 modifier.setStratum( parseStratum( request ) ); 056 modifier.setPollInterval( parsePollInterval( request ) ); 057 modifier.setPrecision( parsePrecision( request ) ); 058 modifier.setRootDelay( parseRootDelay( request ) ); 059 modifier.setRootDispersion( parseRootDispersion( request ) ); 060 modifier.setReferenceIdentifier( parseReferenceIdentifier( request ) ); 061 modifier.setReferenceTimestamp( new NtpTimeStamp( request ) ); 062 modifier.setOriginateTimestamp( new NtpTimeStamp( request ) ); 063 064 byte[] unneededBytes = new byte[8]; 065 request.get( unneededBytes ); 066 067 modifier.setReceiveTimestamp( new NtpTimeStamp() ); 068 modifier.setTransmitTimestamp( new NtpTimeStamp( request ) ); 069 070 return modifier.getNtpMessage(); 071 } 072 073 074 private LeapIndicatorType parseLeapIndicator( byte header ) 075 { 076 return LeapIndicatorType.getTypeByOrdinal( ( header & 0xc0 ) >>> 6 ); 077 } 078 079 080 private int parseVersionNumber( byte header ) 081 { 082 return ( header & 0x38 ) >>> 3; 083 } 084 085 086 private ModeType parseMode( byte header ) 087 { 088 return ModeType.getTypeByOrdinal( header & 0x07 ); 089 } 090 091 092 private StratumType parseStratum( ByteBuffer request ) 093 { 094 return StratumType.getTypeByOrdinal( request.get() ); 095 } 096 097 098 private byte parsePollInterval( ByteBuffer bytes ) 099 { 100 return ( byte ) Math.round( Math.pow( 2, bytes.get() ) ); 101 } 102 103 104 private byte parsePrecision( ByteBuffer bytes ) 105 { 106 return ( byte ) ( 1000 * Math.pow( 2, bytes.get() ) ); 107 } 108 109 110 private ReferenceIdentifier parseReferenceIdentifier( ByteBuffer request ) 111 { 112 byte[] nextFourBytes = new byte[4]; 113 request.get( nextFourBytes ); 114 return ReferenceIdentifier.getTypeByName( new String( nextFourBytes, StandardCharsets.UTF_8 ) ); 115 } 116 117 118 private int parseRootDelay( ByteBuffer bytes ) 119 { 120 int temp = 256 * ( 256 * ( 256 * bytes.get() + bytes.get() ) + bytes.get() ) + bytes.get(); 121 return 1000 * ( temp / 0x10000 ); 122 } 123 124 125 private int parseRootDispersion( ByteBuffer bytes ) 126 { 127 int temp = 256 * ( 256 * ( 256 * bytes.get() + bytes.get() ) + bytes.get() ) + bytes.get(); 128 return 1000 * ( temp / 0x10000 ); 129 } 130}