public void VarintEncodeAndDecodeZero()
{
const ushort number = UInt16.MaxValue / 2;
var encoded = VarintBitConverter.GetVarintBytes(number);
Assert.Equal(number, VarintBitConverter.ToUInt16(encoded));
}
public void VarintEncodeAndDecodeUInt64Read()
{
const ulong number = UInt64.MaxValue / 2;
var encoded = VarintBitConverter.GetVarintBytes(number);
Assert.Equal(number, VarintBitConverter.ReadUInt64(new BinaryReader(new MemoryStream(encoded))));
}
public void VarintEncodeAndDecodeUInt32Zero()
{
const uint number = 0;
var encoded = VarintBitConverter.GetVarintBytes(number);
Assert.Equal(number, VarintBitConverter.ToUInt32(encoded));
}
private void WriteTags(IOSMElement element, List <byte> bytes)
{
if (element.Tags.Count == 0)
{
return;
}
foreach (string tagKey in element.Tags)
{
var tagKeyBytes = Encoding.UTF8.GetBytes(tagKey);
var tagValueBytes = Encoding.UTF8.GetBytes(element.Tags[tagKey]);
var elementPosition = this._storedStringPairs.GetElementPosition(tagKeyBytes, tagValueBytes);
if (elementPosition != -1)
{
var positionBytes = VarintBitConverter.GetVarintBytes((uint)elementPosition);
bytes.AddRange(positionBytes);
}
else
{
var stringPair = new KeyValuePair <byte[], byte[]>(tagKeyBytes, tagValueBytes);
bytes.Add(0x00);
bytes.AddRange(tagKeyBytes);
bytes.Add(0x00);
bytes.AddRange(tagValueBytes);
bytes.Add(0x00);
if (stringPair.Key.Length + stringPair.Value.Length <= 250)
{
this._storedStringPairs.Insert(0, stringPair);
}
}
}
}
public void VarintEncodeAndDecodeUInt64()
{
const ulong number = UInt64.MaxValue / 2;
var encoded = VarintBitConverter.GetVarintBytes(number);
Assert.Equal(number, VarintBitConverter.ToUInt64(encoded));
}
public void VarintEncodeAndDecodeInt64MinValue()
{
const long number = Int64.MinValue;
var encoded = VarintBitConverter.GetVarintBytes(number);
Assert.Equal(number, VarintBitConverter.ToInt64(encoded));
}
public void VarintEncodeAndDecodeInt16Zero()
{
const short number = 0;
var encoded = VarintBitConverter.GetVarintBytes(number);
Assert.Equal(number, VarintBitConverter.ToInt16(encoded));
}
public void VarintEncodeAndDecodeByteMaxValue()
{
const byte number = Byte.MaxValue;
var encoded = VarintBitConverter.GetVarintBytes(number);
Assert.Equal(number, VarintBitConverter.ToByte(encoded));
}
public void VarintEncodeAndDecodeInt32()
{
const int number = Int32.MaxValue / 2;
var encoded = VarintBitConverter.GetVarintBytes(number);
Assert.Equal(number, VarintBitConverter.ToInt32(encoded));
}
public override byte[] Encode(BufferPlus bp, uint value, Encoding encoding = null, int position = -1, int length = -1)
{
bp.SanitizeParameter(ref position, ref length, ref encoding);
var bytes = VarintBitConverter.GetVarintBytes(value);
bp.Memory.Write(bytes, 0, bytes.Length);
return(bytes);
}
private void WriteVersionData(IOSMElement element, List <byte> bytes)
{
if (element.Version == 0)
{
bytes.Add(0x00);
return;
}
var versionBytes = VarintBitConverter.GetVarintBytes(element.Version);
bytes.AddRange(versionBytes);
var timestamp = (long)element.Timestamp.Subtract(UNIX_START).TotalSeconds;
var timestampDiff = timestamp - this._lastTimestamp;
var timestampBytes = VarintBitConverter.GetVarintBytes(timestampDiff);
this._lastTimestamp = timestamp;
bytes.AddRange(timestampBytes);
if (timestamp == 0)
{
return;
}
var changesetDiff = (long)element.Changeset - this._lastChangeset;
var changesetBytes = VarintBitConverter.GetVarintBytes(changesetDiff);
this._lastChangeset = (long)element.Changeset;
bytes.AddRange(changesetBytes);
var uidBytes = VarintBitConverter.GetVarintBytes(element.UserId);
if (element.UserId == 0)
{
uidBytes = new byte[0];
}
var userBytes = Encoding.UTF8.GetBytes(element.UserName);
var elementPosition = this._storedStringPairs.GetElementPosition(uidBytes, userBytes);
if (elementPosition != -1)
{
var positionBytes = VarintBitConverter.GetVarintBytes((uint)elementPosition);
bytes.AddRange(positionBytes);
}
else
{
bytes.Add(0x00);
bytes.AddRange(uidBytes);
bytes.Add(0x00);
bytes.AddRange(userBytes);
bytes.Add(0x00);
var uidUserPair = new KeyValuePair <byte[], byte[]>(uidBytes, userBytes);
if (uidUserPair.Key.Length + uidUserPair.Value.Length <= 250)
{
this._storedStringPairs.Insert(0, uidUserPair);
}
}
}
/// <summary>
/// Writes the timestamp.
/// </summary>
/// <param name="timestamp">Timestamp.</param>
public void WriteTimestamp(DateTime timestamp)
{
this._stream.WriteByte((byte)O5MFileByteMarker.FileTimestamp);
var unixTimestamp = (long)timestamp.Subtract(UNIX_START).TotalSeconds;
var timestampBytes = VarintBitConverter.GetVarintBytes(unixTimestamp);
var timestampBytesLength = VarintBitConverter.GetVarintBytes((ulong)timestampBytes.Length);
this._stream.Write(timestampBytesLength, 0, timestampBytesLength.Length);
this._stream.Write(timestampBytes, 0, timestampBytes.Length);
}
public void VarintEncodeAndDecodeUInt64MoreBytes()
{
const ulong number = UInt64.MaxValue / 2;
var encoded = VarintBitConverter.GetVarintBytes(number);
Assert.Equal(number, VarintBitConverter.ToUInt64(encoded));
var encoded2 = encoded.Concat(new byte[] { 0xa, 0xb }).ToArray();
Assert.Equal(number, VarintBitConverter.ToUInt64(encoded2));
}
public static byte [] GetNearbyCellIds(double longitude, double latitude)
{
var cellIds = new List <byte>();
var cells = _GetNearbyCellIds(longitude, latitude);
foreach (var cellId in cells.OrderBy(c => c))
{
cellIds.AddRange(VarintBitConverter.GetVarintBytes(cellId));
}
return(cellIds.ToArray());
}
public static byte[] EncodeUlongList(List <ulong> integers)
{
var output = new List <byte>();
foreach (var integer in integers.OrderBy(c => c))
{
output.AddRange(VarintBitConverter.GetVarintBytes(integer));
}
return(output.ToArray());
}
private void Init(Stream stream, O5MHeader header = O5MHeader.O5M2)
{
this._stream = stream;
this._stream.WriteByte((byte)O5MFileByteMarker.StartByte);
this._stream.WriteByte((byte)O5MFileByteMarker.Header);
var headerLengthBytes = VarintBitConverter.GetVarintBytes(4U);
var headerBuffer = Encoding.UTF8.GetBytes(header.ToString().ToLower());
this._stream.Write(headerLengthBytes, 0, headerLengthBytes.Length);
this._stream.Write(headerBuffer, 0, headerBuffer.Length);
}
private void sendMessage(IExtensible proto)
{
byte[] x;
using (var ms = new MemoryStream()) {
Serializer.Serialize(ms, proto);
x = ms.ToArray();
}
var _buf = VarintBitConverter.GetVarintBytes((uint)x.Length);
util.debugWriteLine("sendmessage mcs " + _buf + " x len " + x.Length + " " + proto);
sslStream.Write(_buf);
sslStream.Write(x);
sslStream.Flush();
}
/// <summary>
/// Writes the boundings.
/// </summary>
/// <param name="latitudeMin">Minimum Latitude.</param>
/// <param name="latitudeMax">Maximum Latitude.</param>
/// <param name="longitudeMin">Minimum Longitude.</param>
/// <param name="longitudeMax">Maximum Longitude.</param>
public void WriteBoundings(double latitudeMin, double latitudeMax, double longitudeMin, double longitudeMax)
{
this._stream.WriteByte((byte)O5MFileByteMarker.BoundingBox);
var longitudeMinLongBytes = VarintBitConverter.GetVarintBytes((long)(longitudeMin * POINT_DIVIDER));
var latitudeMinLongBytes = VarintBitConverter.GetVarintBytes((long)(latitudeMin * POINT_DIVIDER));
var longitudeMaxLongBytes = VarintBitConverter.GetVarintBytes((long)(longitudeMax * POINT_DIVIDER));
var latitudeMaxLongBytes = VarintBitConverter.GetVarintBytes((long)(latitudeMax * POINT_DIVIDER));
var boundingBytesLength = VarintBitConverter.GetVarintBytes((ulong)(longitudeMinLongBytes.Length + latitudeMinLongBytes.Length + longitudeMaxLongBytes.Length + latitudeMaxLongBytes.Length));
this._stream.Write(boundingBytesLength, 0, boundingBytesLength.Length);
this._stream.Write(longitudeMinLongBytes, 0, longitudeMinLongBytes.Length);
this._stream.Write(latitudeMinLongBytes, 0, latitudeMinLongBytes.Length);
this._stream.Write(longitudeMaxLongBytes, 0, longitudeMaxLongBytes.Length);
this._stream.Write(latitudeMaxLongBytes, 0, latitudeMaxLongBytes.Length);
}
private void WriteWay(OSMWay way, out byte[] writtenData)
{
if (!this._waysStarted)
{
this.Reset();
this._stream.WriteByte((byte)O5MFileByteMarker.Reset);
this._waysStarted = true;
}
this._stream.WriteByte((byte)O5MFileByteMarker.Way);
var bytes = new List <byte>();
var diffId = (long)way.Id - this._lastWayId;
var idBytes = VarintBitConverter.GetVarintBytes(diffId);
bytes.AddRange(idBytes);
this._lastWayId = (long)way.Id;
this.WriteVersionData(way, bytes);
if (way.NodeRefs.Count == 0)
{
bytes.Add(0x00);
}
else
{
var nodeRefsBytes = new List <byte>();
foreach (var nodeRef in way.NodeRefs)
{
var nextReferenceDiff = (long)nodeRef - this._lastReferenceId;
var nodeRefBytes = VarintBitConverter.GetVarintBytes(nextReferenceDiff);
this._lastReferenceId = (long)nodeRef;
nodeRefsBytes.AddRange(nodeRefBytes);
}
var nodeRefsBytesCountBytes = VarintBitConverter.GetVarintBytes((ulong)nodeRefsBytes.Count);
bytes.AddRange(nodeRefsBytesCountBytes);
bytes.AddRange(nodeRefsBytes);
}
this.WriteTags(way, bytes);
var length = VarintBitConverter.GetVarintBytes((ulong)bytes.Count);
this._stream.Write(length, 0, length.Length);
writtenData = bytes.ToArray();
this._stream.Write(writtenData, 0, bytes.Count);
}
private void WriteNode(OSMNode node, out byte[] writtenData)
{
if (!this._nodesStarted)
{
this.Reset();
this._stream.WriteByte((byte)O5MFileByteMarker.Reset);
this._nodesStarted = true;
}
this._stream.WriteByte((byte)O5MFileByteMarker.Node);
var bytes = new List <byte>();
var diffId = (long)node.Id - this._lastNodeId;
var idBytes = VarintBitConverter.GetVarintBytes(diffId);
bytes.AddRange(idBytes);
this._lastNodeId = (long)node.Id;
this.WriteVersionData(node, bytes);
var varIntLongitude = (int)Math.Round(node.Longitude * POINT_DIVIDER);
var diffLongitude = varIntLongitude - this._lastLongitude;
var longitudeBytes = VarintBitConverter.GetVarintBytes(diffLongitude);
bytes.AddRange(longitudeBytes);
this._lastLongitude = varIntLongitude;
var varIntLatitude = (int)Math.Round(node.Latitude * POINT_DIVIDER);
var diffLatitude = varIntLatitude - this._lastLatitude;
var latitudeBytes = VarintBitConverter.GetVarintBytes(diffLatitude);
bytes.AddRange(latitudeBytes);
this._lastLatitude = varIntLatitude;
this.WriteTags(node, bytes);
var length = VarintBitConverter.GetVarintBytes((ulong)bytes.Count);
this._stream.Write(length, 0, length.Length);
writtenData = bytes.ToArray();
this._stream.Write(writtenData, 0, bytes.Count);
}
public bool connectMcs(string androidId, string securityToken)
{
util.debugWriteLine("connectMcs " + androidId + " " + securityToken);
try
{
var lr = new LoginRequest();
lr.AdaptiveHeartbeat = false;
lr.auth_service = LoginRequest.AuthService.AndroidId;
lr.AuthToken = securityToken;
lr.Id = "android-11";
lr.Domain = "mcs.android.com";
lr.DeviceId = "android-" + long.Parse(androidId).ToString("x");
lr.NetworkType = 1;
lr.Resource = androidId;
lr.User = androidId;
lr.UseRmq2 = true;
lr.AccountId = long.Parse(androidId);
lr.ReceivedPersistentIds.Add(""); //# possible source of error
var setting = new Setting();
setting.Name = "new_vc";
setting.Value = "1";
lr.Settings.Add(setting);
//var x = lr.ToByteArray();
byte[] x;
using (var ms = new MemoryStream())
{
Serializer.Serialize(ms, lr);
x = ms.ToArray();
}
using (var client = new TcpClient("mtalk.google.com", 5228))
using (sslStream = new SslStream(client.GetStream(), false, delegate { return(true); }))
{
sslStream.AuthenticateAsClient("mtalk.google.com");
//var _buf = VarintBitConverter.GetVarintBytes((int)x.Length);
var _buf = VarintBitConverter.GetVarintBytes((uint)x.Length);
/*
* var num = x.Length;
* var _buf = new List<byte>();
* while (true) {
* var towrite = num & 0x7f;
* num >>= 7;
* if (num == 1)
* _buf.Add((byte)(towrite | 0x80));
* else {
* _buf.Add((byte)towrite);
* break;
* }
* }
*/
//util.debugWriteLine(_buf.ToArray() + " x len " + x.Length);
util.debugWriteLine(_buf + " x len " + x.Length);
sslStream.Write(new byte[] { 41, 2 });
sslStream.Write(_buf);
sslStream.Write(x);
sslStream.Flush();
var version = sslStream.ReadByte();
util.debugWriteLine(version);
Task.Factory.StartNew(() =>
{
while (isRetry)
{
//Thread.Sleep(15000);
Thread.Sleep(60 * 60 * 1000);
util.debugWriteLine(DateTime.Now.ToString() + " ping " + sslStream.GetHashCode());
try
{
sslStream.Write(new byte[] { 0x07, 0x0e, 0x10, 0x01, 0x1a, 0x00, 0x3a, 0x04, 0x08, 0x0d, 0x12, 0x00, 0x50, 0x03, 0x60, 0x00 });
//s.send(b'\x00\x04\x10\x08\x18\x00')
}
catch (Exception e)
{
util.debugWriteLine("ping error " + e.Message + e.Source + e.StackTrace + e.TargetSite);
break;
}
}
util.debugWriteLine("ping end " + sslStream.GetHashCode());
});
while (isRetry)
{
var responseTag = sslStream.ReadByte();
util.debugWriteLine(DateTime.Now + " resp tag " + responseTag + " " + (char)responseTag);
var msg = new List <byte>();
if (responseTag == 0x03 || responseTag == 0x07 ||
responseTag == 0x08)
{
//var length = varIntDecodeStream(sslStream);
var length = 0;
var _lenBuf = new List <byte>();
for (var i = 0; i < 10; i++)
{
var _slb = sslStream.ReadByte();
_lenBuf.Add((byte)_slb);
if (_lenBuf[_lenBuf.Count - 1] > 128)
{
_lenBuf.Add((byte)sslStream.ReadByte());
}
try
{
length = VarintBitConverter.ToInt32(_lenBuf.ToArray()) * 1;
var length2 = VarintBitConverter.ToInt16(_lenBuf.ToArray()) * 1;
var length3 = VarintBitConverter.ToInt64(_lenBuf.ToArray()) * 1;
var length4 = VarintBitConverter.ToUInt16(_lenBuf.ToArray()) * 1;
var length5 = VarintBitConverter.ToUInt32(_lenBuf.ToArray()) * 1;
length = (int)length5;
break;
}
catch (Exception e)
{
util.debugWriteLine(e.Message + e.Source + e.StackTrace + e.TargetSite);
}
}
if (length == 0)
{
return(false);
}
util.debugWriteLine("calc len " + length);
while (msg.Count < length)
{
if (msg.Count != 0)
{
util.debugWriteLine("recv msg 2shuume");
}
byte[] readbuf = new byte[1000];
var i = sslStream.Read(readbuf, 0, length - msg.Count);
for (var j = 0; j < i; j++)
{
msg.Add(readbuf[j]);
}
util.debugWriteLine("recv allLen " + length + " msg len " + msg.Count + " " + msg);
}
util.debugWriteLine("calc len " + length + " msg len " + msg.Count + " msg " + msg);
//foreach (var bb in msg) Debug.Write((char)bb);
//util.debugWriteLine("");
//foreach (var bb in msg) Debug.Write(bb.ToString("x") + " ");
util.debugWriteLine("");
}
if (responseTag == 0x03)
{
var lresp = new LoginResponse();
using (var ms = new MemoryStream(msg.ToArray()))
{
lresp = Serializer.Deserialize <LoginResponse>(ms);
}
/*
* using (var ms = new MemoryStream(msg.ToArray()))
* using (var cs = new CodedInputStream(ms)) {
* lresp.MergeFrom(cs);
*
* }
*/
util.debugWriteLine("RECV LOGIN RESP " + lresp);
}
else if (responseTag == 0x07)
{
//var lresp = LoginResponse.Parser.ParseFrom(msg.ToArray());
var lresp = new IqStanza();
using (var ms = new MemoryStream(msg.ToArray()))
{
lresp = Serializer.Deserialize <IqStanza>(ms);
}
/*
* using (var ms = new MemoryStream(msg.ToArray()))
* using (var cs = new CodedInputStream(ms)) {
* //lresp.MergeFrom(cs);
* try {
* var iqstanza = IqStanza.Parser.ParseFrom(msg.ToArray());
* } catch (Exception e) {
* util.debugWriteLine(e.Message + e.Source + e.StackTrace + e.TargetSite);
* }
*
* //util.debugWriteLine(iqstanza);
* //LoginResponse.Descriptor.
* }
*/
//iqs = mcs_pb2.IqStanza();
//iqs.ParseFromString(msg);
util.debugWriteLine("RECV IQ id " + lresp); // + lresp.Id + " time " + lresp.ServerTimestamp + " streamid " + lresp.StreamId + " ");
}
else if (responseTag == 0x08)
{
try
{
DataMessageStanza lresp;
using (var ms = new MemoryStream(msg.ToArray()))
{
lresp = Serializer.Deserialize <DataMessageStanza>(ms);
}
//var lresp = DataMessageStanza.Parser.ParseFrom(msg.ToArray());
//dms = mcs_pb2.DataMessageStanza();
//dms.ParseFromString(msg);
util.debugWriteLine("RECV DATA MESSAGE " + lresp); //lresp.Id + " time " + lresp.ServerTimestamp + " streamid " + lresp.StreamId + " ");
//var lvid = util.getRegGroup(lresp.AppData.ToString(), "\"lvid\"[\\s\\S]+(lv\\d+)");
//var lvid = util.getRegGroup(lresp.AppData.ToString(), "\"program_id\":\"(lv\\d+)");
var d = "";
foreach (var a in lresp.AppDatas)
{
d += a.Value;
}
//var lvid = util.getRegGroup(d, "program_id\\\\\":\\\\\"(lv\\d+)"); google protobuf
var lvid = util.getRegGroup(d, "program_id\":\"(lv\\d+)"); //google protobuf
if (lvid != null)
{
util.debugWriteLine("appData lvid " + lvid);
var items = getNicoCasItem(lvid, lresp);
if (items != null)
{
check.foundLive(items);
}
else
{
var gir = new GetItemRetryApr(lvid, lresp, this);
Task.Factory.StartNew(() =>
{
for (var i = 0; i < 10; i++)
{
Thread.Sleep(5000);
items = gir.getItem();
if (items == null)
{
continue;
}
check.foundLive(items);
break;
}
});
}
}
}
catch (Exception ee)
{
util.debugWriteLine(ee.Message + ee.Source + ee.StackTrace + ee.TargetSite);
}
}
else if (responseTag == 0x04)
{
break;
}
else
{
if (responseTag == 0x00)
{
break;
}
util.debugWriteLine("unknown response: " + responseTag.ToString());
}
}
}
util.debugWriteLine("closed");
return(true);
}
catch (Exception e)
{
util.debugWriteLine("mcs connect error " + e.Message + e.Source + e.StackTrace + e.TargetSite);
return(false);
}
}
private void WriteRelation(OSMRelation relation, out byte[] writtenData)
{
if (!this._relationsStarted)
{
this.Reset();
this._stream.WriteByte((byte)O5MFileByteMarker.Reset);
this._relationsStarted = true;
}
this._stream.WriteByte((byte)O5MFileByteMarker.Relation);
var bytes = new List <byte>();
var diffId = (long)relation.Id - this._lastRelationId;
var idBytes = VarintBitConverter.GetVarintBytes(diffId);
bytes.AddRange(idBytes);
this._lastRelationId = (long)relation.Id;
this.WriteVersionData(relation, bytes);
if (relation.Members.Count == 0)
{
bytes.Add(0x00);
}
else
{
var membersBytes = new List <byte>();
foreach (var member in relation.Members)
{
var nextReferenceDiff = (long)member.Ref - this._lastReferenceId;
var memberRefBytes = VarintBitConverter.GetVarintBytes(nextReferenceDiff);
this._lastReferenceId = (long)member.Ref;
membersBytes.AddRange(memberRefBytes);
var typeBytes = new byte[] { (byte)((int)member.Type + 0x30) };
var roleBytes = Encoding.UTF8.GetBytes(member.Role);
var position = this._storedStringPairs.GetElementPosition(typeBytes, roleBytes);
if (position == -1)
{
membersBytes.Add(0x00);
membersBytes.AddRange(typeBytes);
membersBytes.AddRange(roleBytes);
membersBytes.Add(0x00);
if (1 + roleBytes.Length <= 250)
{
var typeAndRole = new KeyValuePair <byte[], byte[]>(typeBytes, roleBytes);
this._storedStringPairs.Insert(0, typeAndRole);
}
}
else
{
var positionBytes = VarintBitConverter.GetVarintBytes((uint)position);
membersBytes.AddRange(positionBytes);
}
}
var membersBytesCountBytes = VarintBitConverter.GetVarintBytes((ulong)membersBytes.Count);
bytes.AddRange(membersBytesCountBytes);
bytes.AddRange(membersBytes);
}
this.WriteTags(relation, bytes);
var length = VarintBitConverter.GetVarintBytes((ulong)bytes.Count);
this._stream.Write(length, 0, length.Length);
writtenData = bytes.ToArray();
this._stream.Write(writtenData, 0, bytes.Count);
}
/// <summary>
/// Returns 64-bit signed value from varint encoded array of bytes.
/// </summary>
/// <param name="writer">Varint encoded array of bytes.</param>
/// <param name="value"></param>
/// <returns>64-bit signed value</returns>
public static void WriteVarint(this BinaryWriter writer, ulong value)
{
var encoded = VarintBitConverter.GetVarintBytes(value);
writer.Write(encoded);
}
public void PutVarUInt64(ulong v) => VarintBitConverter.GetVarintBytes(v, Buffer, ref Offset);
public void PutVarUInt32(uint v) => VarintBitConverter.GetVarintBytes(v, Buffer, ref Offset);
