1 /*
2 * Copyright 2014 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 * ring.c - packet ring buffer functions
17 */
18
19 #include <errno.h>
20 #include <string.h>
21 #include <arpa/inet.h>
22 #include <sys/socket.h>
23 #include <sys/mman.h>
24 #include <linux/if.h>
25 #include <linux/if_packet.h>
26
27 #include "logging.h"
28 #include "ring.h"
29 #include "translate.h"
30 #include "tun.h"
31
ring_create(struct tun_data * tunnel)32 int ring_create(struct tun_data *tunnel) {
33 int packetsock = socket(AF_PACKET, SOCK_DGRAM, htons(ETH_P_IPV6));
34 if (packetsock < 0) {
35 logmsg(ANDROID_LOG_FATAL, "packet socket failed: %s", strerror(errno));
36 return -1;
37 }
38
39 int ver = TPACKET_V2;
40 if (setsockopt(packetsock, SOL_PACKET, PACKET_VERSION, (void *) &ver, sizeof(ver))) {
41 logmsg(ANDROID_LOG_FATAL, "setsockopt(PACKET_VERSION, %d) failed: %s", ver, strerror(errno));
42 return -1;
43 }
44
45 int on = 1;
46 if (setsockopt(packetsock, SOL_PACKET, PACKET_LOSS, (void *) &on, sizeof(on))) {
47 logmsg(ANDROID_LOG_WARN, "PACKET_LOSS failed: %s", strerror(errno));
48 }
49
50 struct packet_ring *ring = &tunnel->ring;
51 ring->numblocks = TP_NUM_BLOCKS;
52
53 int total_frames = TP_FRAMES * ring->numblocks;
54
55 struct tpacket_req req = {
56 .tp_frame_size = TP_FRAME_SIZE, // Frame size.
57 .tp_block_size = TP_BLOCK_SIZE, // Frames per block.
58 .tp_block_nr = ring->numblocks, // Number of blocks.
59 .tp_frame_nr = total_frames, // Total frames.
60 };
61
62 if (setsockopt(packetsock, SOL_PACKET, PACKET_RX_RING, &req, sizeof(req)) < 0) {
63 logmsg(ANDROID_LOG_FATAL, "PACKET_RX_RING failed: %s", strerror(errno));
64 return -1;
65 }
66
67 size_t buflen = TP_BLOCK_SIZE * ring->numblocks;
68 ring->base = mmap(NULL, buflen, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_LOCKED|MAP_POPULATE,
69 packetsock, 0);
70 if (ring->base == MAP_FAILED) {
71 logmsg(ANDROID_LOG_FATAL, "mmap %lu failed: %s", buflen, strerror(errno));
72 return -1;
73 }
74
75 ring->block = 0;
76 ring->slot = 0;
77 ring->numslots = TP_BLOCK_SIZE / TP_FRAME_SIZE;
78 ring->next = (struct tpacket2_hdr *) ring->base;
79
80 logmsg(ANDROID_LOG_INFO, "Using ring buffer with %d frames (%d bytes) at %p",
81 total_frames, buflen, ring->base);
82
83 return packetsock;
84 }
85
86 /* function: ring_advance
87 * advances to the next position in the packet ring
88 * ring - packet ring buffer
89 */
ring_advance(struct packet_ring * ring)90 static struct tpacket2_hdr* ring_advance(struct packet_ring *ring) {
91 uint8_t *next = (uint8_t *) ring->next;
92
93 ring->slot++;
94 next += TP_FRAME_SIZE;
95
96 if (ring->slot == ring->numslots) {
97 ring->slot = 0;
98 ring->block++;
99
100 if (ring->block < ring->numblocks) {
101 next += TP_FRAME_GAP;
102 } else {
103 ring->block = 0;
104 next = (uint8_t *) ring->base;
105 }
106 }
107
108 ring->next = (struct tpacket2_hdr *) next;
109 return ring->next;
110 }
111
112 /* function: ring_read
113 * reads a packet from the ring buffer and translates it
114 * read_fd - file descriptor to read original packet from
115 * write_fd - file descriptor to write translated packet to
116 * to_ipv6 - whether the packet is to be translated to ipv6 or ipv4
117 */
ring_read(struct packet_ring * ring,int write_fd,int to_ipv6)118 void ring_read(struct packet_ring *ring, int write_fd, int to_ipv6) {
119 struct tpacket2_hdr *tp = ring->next;
120 if (tp->tp_status & TP_STATUS_USER) {
121 uint8_t *packet = ((uint8_t *) tp) + tp->tp_net;
122 translate_packet(write_fd, to_ipv6, packet, tp->tp_len);
123 tp->tp_status = TP_STATUS_KERNEL;
124 tp = ring_advance(ring);
125 }
126 }
127