1 /*
2 * Copyright 2011 Daniel Drown
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 * dump.c - print various headers for debugging
17 */
18 #include <stdint.h>
19 #include <stdio.h>
20 #include <stdlib.h>
21
22 #include <arpa/inet.h>
23 #include <linux/icmp.h>
24 #include <netinet/icmp6.h>
25 #include <netinet/in.h>
26 #include <netinet/ip.h>
27 #include <netinet/ip6.h>
28 #include <netinet/ip_icmp.h>
29 #include <netinet/tcp.h>
30 #include <netinet/udp.h>
31
32 #include "netutils/checksum.h"
33
34 #include "clatd.h"
35 #include "debug.h"
36 #include "logging.h"
37
38 #if CLAT_DEBUG
39
40 /* print ip header */
dump_ip(struct iphdr * header)41 void dump_ip(struct iphdr *header) {
42 u_int16_t frag_flags;
43 char addrstr[INET6_ADDRSTRLEN];
44
45 frag_flags = ntohs(header->frag_off);
46
47 printf("IP packet\n");
48 printf("header_len = %x\n", header->ihl);
49 printf("version = %x\n", header->version);
50 printf("tos = %x\n", header->tos);
51 printf("tot_len = %x\n", ntohs(header->tot_len));
52 printf("id = %x\n", ntohs(header->id));
53 printf("frag: ");
54 if (frag_flags & IP_RF) {
55 printf("(RF) ");
56 }
57 if (frag_flags & IP_DF) {
58 printf("DF ");
59 }
60 if (frag_flags & IP_MF) {
61 printf("MF ");
62 }
63 printf("offset = %x\n", frag_flags & IP_OFFMASK);
64 printf("ttl = %x\n", header->ttl);
65 printf("protocol = %x\n", header->protocol);
66 printf("checksum = %x\n", ntohs(header->check));
67 inet_ntop(AF_INET, &header->saddr, addrstr, sizeof(addrstr));
68 printf("saddr = %s\n", addrstr);
69 inet_ntop(AF_INET, &header->daddr, addrstr, sizeof(addrstr));
70 printf("daddr = %s\n", addrstr);
71 }
72
73 /* print ip6 header */
dump_ip6(struct ip6_hdr * header)74 void dump_ip6(struct ip6_hdr *header) {
75 char addrstr[INET6_ADDRSTRLEN];
76
77 printf("ipv6\n");
78 printf("version = %x\n", header->ip6_vfc >> 4);
79 printf("traffic class = %x\n", header->ip6_flow >> 20);
80 printf("flow label = %x\n", ntohl(header->ip6_flow & 0x000fffff));
81 printf("payload len = %x\n", ntohs(header->ip6_plen));
82 printf("next header = %x\n", header->ip6_nxt);
83 printf("hop limit = %x\n", header->ip6_hlim);
84
85 inet_ntop(AF_INET6, &header->ip6_src, addrstr, sizeof(addrstr));
86 printf("source = %s\n", addrstr);
87
88 inet_ntop(AF_INET6, &header->ip6_dst, addrstr, sizeof(addrstr));
89 printf("dest = %s\n", addrstr);
90 }
91
92 /* print icmp header */
dump_icmp(struct icmphdr * icmp)93 void dump_icmp(struct icmphdr *icmp) {
94 printf("ICMP\n");
95
96 printf("icmp.type = %x ", icmp->type);
97 if (icmp->type == ICMP_ECHOREPLY) {
98 printf("echo reply");
99 } else if (icmp->type == ICMP_ECHO) {
100 printf("echo request");
101 } else {
102 printf("other");
103 }
104 printf("\n");
105 printf("icmp.code = %x\n", icmp->code);
106 printf("icmp.checksum = %x\n", ntohs(icmp->checksum));
107 if (icmp->type == ICMP_ECHOREPLY || icmp->type == ICMP_ECHO) {
108 printf("icmp.un.echo.id = %x\n", ntohs(icmp->un.echo.id));
109 printf("icmp.un.echo.sequence = %x\n", ntohs(icmp->un.echo.sequence));
110 }
111 }
112
113 /* print icmp6 header */
dump_icmp6(struct icmp6_hdr * icmp6)114 void dump_icmp6(struct icmp6_hdr *icmp6) {
115 printf("ICMP6\n");
116 printf("type = %x", icmp6->icmp6_type);
117 if (icmp6->icmp6_type == ICMP6_ECHO_REQUEST) {
118 printf("(echo request)");
119 } else if (icmp6->icmp6_type == ICMP6_ECHO_REPLY) {
120 printf("(echo reply)");
121 }
122 printf("\n");
123 printf("code = %x\n", icmp6->icmp6_code);
124
125 printf("checksum = %x\n", icmp6->icmp6_cksum);
126
127 if ((icmp6->icmp6_type == ICMP6_ECHO_REQUEST) || (icmp6->icmp6_type == ICMP6_ECHO_REPLY)) {
128 printf("icmp6_id = %x\n", icmp6->icmp6_id);
129 printf("icmp6_seq = %x\n", icmp6->icmp6_seq);
130 }
131 }
132
133 /* print udp header */
dump_udp_generic(const struct udphdr * udp,uint32_t temp_checksum,const uint8_t * payload,size_t payload_size)134 void dump_udp_generic(const struct udphdr *udp, uint32_t temp_checksum, const uint8_t *payload,
135 size_t payload_size) {
136 uint16_t my_checksum;
137
138 temp_checksum = ip_checksum_add(temp_checksum, udp, sizeof(struct udphdr));
139 temp_checksum = ip_checksum_add(temp_checksum, payload, payload_size);
140 my_checksum = ip_checksum_finish(temp_checksum);
141
142 printf("UDP\n");
143 printf("source = %x\n", ntohs(udp->source));
144 printf("dest = %x\n", ntohs(udp->dest));
145 printf("len = %x\n", ntohs(udp->len));
146 printf("check = %x (mine %x)\n", udp->check, my_checksum);
147 }
148
149 /* print ipv4/udp header */
dump_udp(const struct udphdr * udp,const struct iphdr * ip,const uint8_t * payload,size_t payload_size)150 void dump_udp(const struct udphdr *udp, const struct iphdr *ip, const uint8_t *payload,
151 size_t payload_size) {
152 uint32_t temp_checksum;
153 temp_checksum = ipv4_pseudo_header_checksum(ip, sizeof(*udp) + payload_size);
154 dump_udp_generic(udp, temp_checksum, payload, payload_size);
155 }
156
157 /* print ipv6/udp header */
dump_udp6(const struct udphdr * udp,const struct ip6_hdr * ip6,const uint8_t * payload,size_t payload_size)158 void dump_udp6(const struct udphdr *udp, const struct ip6_hdr *ip6, const uint8_t *payload,
159 size_t payload_size) {
160 uint32_t temp_checksum;
161 temp_checksum = ipv6_pseudo_header_checksum(ip6, sizeof(*udp) + payload_size, IPPROTO_UDP);
162 dump_udp_generic(udp, temp_checksum, payload, payload_size);
163 }
164
165 /* print tcp header */
dump_tcp_generic(const struct tcphdr * tcp,const uint8_t * options,size_t options_size,uint32_t temp_checksum,const uint8_t * payload,size_t payload_size)166 void dump_tcp_generic(const struct tcphdr *tcp, const uint8_t *options, size_t options_size,
167 uint32_t temp_checksum, const uint8_t *payload, size_t payload_size) {
168 uint16_t my_checksum;
169
170 temp_checksum = ip_checksum_add(temp_checksum, tcp, sizeof(struct tcphdr));
171 if (options) {
172 temp_checksum = ip_checksum_add(temp_checksum, options, options_size);
173 }
174 temp_checksum = ip_checksum_add(temp_checksum, payload, payload_size);
175 my_checksum = ip_checksum_finish(temp_checksum);
176
177 printf("TCP\n");
178 printf("source = %x\n", ntohs(tcp->source));
179 printf("dest = %x\n", ntohs(tcp->dest));
180 printf("seq = %x\n", ntohl(tcp->seq));
181 printf("ack = %x\n", ntohl(tcp->ack_seq));
182 printf("d_off = %x\n", tcp->doff);
183 printf("res1 = %x\n", tcp->res1);
184 #ifdef __BIONIC__
185 printf("CWR = %x\n", tcp->cwr);
186 printf("ECE = %x\n", tcp->ece);
187 #else
188 printf("CWR/ECE = %x\n", tcp->res2);
189 #endif
190 printf("urg = %x ack = %x psh = %x rst = %x syn = %x fin = %x\n", tcp->urg, tcp->ack,
191 tcp->psh, tcp->rst, tcp->syn, tcp->fin);
192 printf("window = %x\n", ntohs(tcp->window));
193 printf("check = %x [mine %x]\n", tcp->check, my_checksum);
194 printf("urgent = %x\n", tcp->urg_ptr);
195
196 if (options) {
197 size_t i;
198
199 printf("options: ");
200 for (i = 0; i < options_size; i++) {
201 printf("%x ", *(options + i));
202 }
203 printf("\n");
204 }
205 }
206
207 /* print ipv4/tcp header */
dump_tcp(const struct tcphdr * tcp,const struct iphdr * ip,const uint8_t * payload,size_t payload_size,const uint8_t * options,size_t options_size)208 void dump_tcp(const struct tcphdr *tcp, const struct iphdr *ip, const uint8_t *payload,
209 size_t payload_size, const uint8_t *options, size_t options_size) {
210 uint32_t temp_checksum;
211
212 temp_checksum = ipv4_pseudo_header_checksum(ip, sizeof(*tcp) + options_size + payload_size);
213 dump_tcp_generic(tcp, options, options_size, temp_checksum, payload, payload_size);
214 }
215
216 /* print ipv6/tcp header */
dump_tcp6(const struct tcphdr * tcp,const struct ip6_hdr * ip6,const uint8_t * payload,size_t payload_size,const uint8_t * options,size_t options_size)217 void dump_tcp6(const struct tcphdr *tcp, const struct ip6_hdr *ip6, const uint8_t *payload,
218 size_t payload_size, const uint8_t *options, size_t options_size) {
219 uint32_t temp_checksum;
220
221 temp_checksum =
222 ipv6_pseudo_header_checksum(ip6, sizeof(*tcp) + options_size + payload_size, IPPROTO_TCP);
223 dump_tcp_generic(tcp, options, options_size, temp_checksum, payload, payload_size);
224 }
225
226 /* generic hex dump */
logcat_hexdump(const char * info,const uint8_t * data,size_t len)227 void logcat_hexdump(const char *info, const uint8_t *data, size_t len) {
228 char output[PACKETLEN * 3 + 2];
229 size_t i;
230
231 output[0] = '\0';
232 for (i = 0; i < len && i < PACKETLEN; i++) {
233 snprintf(output + i * 3, 4, " %02x", data[i]);
234 }
235 output[len * 3 + 3] = '\0';
236
237 logmsg(ANDROID_LOG_WARN, "info %s len %d data%s", info, len, output);
238 }
239
dump_iovec(const struct iovec * iov,int iov_len)240 void dump_iovec(const struct iovec *iov, int iov_len) {
241 int i;
242 char *str;
243 for (i = 0; i < iov_len; i++) {
244 asprintf(&str, "iov[%d]: ", i);
245 logcat_hexdump(str, iov[i].iov_base, iov[i].iov_len);
246 free(str);
247 }
248 }
249 #endif // CLAT_DEBUG
250