1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
//
// Mono.Net.Dns.DnsPacket
//
// Authors:
// Gonzalo Paniagua Javier (gonzalo.mono@gmail.com)
//
// Copyright 2011 Gonzalo Paniagua Javier
//
// 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.
//
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
namespace Mono.Net.Dns {
abstract class DnsPacket {
protected byte [] packet;
protected int position;
protected DnsHeader header;
protected DnsPacket ()
{
// Caller has to initialize packet, position and header
}
protected DnsPacket (int length)
: this (new byte [length], length)
{
}
protected DnsPacket (byte [] buffer, int length)
{
if (buffer == null)
throw new ArgumentNullException("buffer");
if (length <= 0)
throw new ArgumentOutOfRangeException("length", "Must be greater than zero.");
packet = buffer;
position = length;
header = new DnsHeader(new ArraySegment<byte>(packet, 0, 12));
}
public byte [] Packet {
get { return packet; }
}
public int Length {
get { return position; }
}
public DnsHeader Header {
get { return header; }
}
protected void WriteUInt16 (ushort v)
{
packet [position++] = (byte) ((v & 0x0ff00) >> 8);
packet [position++] = (byte) (v & 0x0ff);
}
protected void WriteStringBytes (string str, int offset, int count)
{
for (int i = offset, c = 0; c < count; c++, i++)
packet [position++] = (byte) str [i]; // Don't care about encoding.
}
protected void WriteLabel (string str, int offset, int count)
{
packet [position++] = (byte) count;
WriteStringBytes (str, offset, count);
}
protected void WriteDnsName (string name)
{
if (!DnsUtil.IsValidDnsName (name))
throw new ArgumentException ("Invalid DNS name");
if (!String.IsNullOrEmpty (name)) {
int len = name.Length;
int label_start = 0;
int label_len = 0;
for (int i = 0; i < len; i++) {
char c = name [i];
if (c != '.') {
label_len++;
} else {
if (i == 0)
break; // "."
WriteLabel (name, label_start, label_len);
label_start += label_len + 1; // Skip the dot
label_len = 0;
}
}
if (label_len > 0)
WriteLabel (name, label_start, label_len);
}
packet [position++] = 0;
}
protected internal string ReadName (ref int offset)
{
return DnsUtil.ReadName (packet, ref offset);
}
protected internal static string ReadName (byte [] buffer, ref int offset)
{
return DnsUtil.ReadName (buffer, ref offset);
}
protected internal ushort ReadUInt16 (ref int offset)
{
return (ushort)((packet[offset++] << 8) + packet[offset++]);
}
protected internal int ReadInt32 (ref int offset)
{
return (packet [offset++] << 24) + (packet [offset++] << 16) + (packet [offset++] << 8) + packet [offset++];
}
}
}
|
