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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
|
/*
* netsniff-ng - the packet sniffing beast
* Copyright 2009, 2010 Daniel Borkmann.
* Subject to the GPL, version 2.
*/
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <syslog.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <linux/if.h>
#include <linux/if_tun.h>
#include "die.h"
#include "xio.h"
#include "str.h"
#include "xutils.h"
int open_or_die(const char *file, int flags)
{
int ret = open(file, flags);
if (ret < 0)
panic("Cannot open file %s! %s.\n", file, strerror(errno));
return ret;
}
int open_or_die_m(const char *file, int flags, mode_t mode)
{
int ret = open(file, flags, mode);
if (ret < 0)
panic("Cannot open or create file %s! %s.", file, strerror(errno));
return ret;
}
void create_or_die(const char *file, mode_t mode)
{
int fd = open_or_die_m(file, O_WRONLY | O_CREAT, mode);
close(fd);
}
void pipe_or_die(int pipefd[2], int flags)
{
int ret = pipe2(pipefd, flags);
if (ret < 0)
panic("Cannot create pipe2 event fd! %s.\n", strerror(errno));
}
int tun_open_or_die(char *name, int type)
{
int fd, ret;
short flags;
struct ifreq ifr;
if (!name)
panic("No name provided for tundev!\n");
fd = open_or_die("/dev/net/tun", O_RDWR);
memset(&ifr, 0, sizeof(ifr));
ifr.ifr_flags = type;
strlcpy(ifr.ifr_name, name, IFNAMSIZ);
ret = ioctl(fd, TUNSETIFF, &ifr);
if (ret < 0)
panic("ioctl screwed up! %s.\n", strerror(errno));
ret = fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
if (ret < 0)
panic("fctnl screwed up! %s.\n", strerror(errno));
flags = device_get_flags(name);
flags |= IFF_UP | IFF_RUNNING;
device_set_flags(name, flags);
return fd;
}
ssize_t read_or_die(int fd, void *buf, size_t len)
{
ssize_t ret = read(fd, buf, len);
if (ret < 0) {
if (errno == EPIPE)
die();
panic("Cannot read from descriptor! %s.\n", strerror(errno));
}
return ret;
}
ssize_t write_or_die(int fd, const void *buf, size_t len)
{
ssize_t ret = write(fd, buf, len);
if (ret < 0) {
if (errno == EPIPE)
die();
panic("Cannot write to descriptor! %s.", strerror(errno));
}
return ret;
}
extern volatile sig_atomic_t sigint;
ssize_t read_exact(int fd, void *buf, size_t len, int mayexit)
{
ssize_t num = 0, written;
while (len > 0 && !sigint) {
if ((written = read(fd, buf, len)) < 0) {
if (errno == EAGAIN && num > 0)
continue;
if (mayexit)
return -1;
else
continue;
}
if (!written)
return 0;
len -= written;
buf += written;
num += written;
}
return num;
}
ssize_t write_exact(int fd, void *buf, size_t len, int mayexit)
{
ssize_t num = 0, written;
while (len > 0 && !sigint) {
if ((written = write(fd, buf, len)) < 0) {
if (errno == EAGAIN && num > 0)
continue;
if (mayexit)
return -1;
else
continue;
}
if (!written)
return 0;
len -= written;
buf += written;
num += written;
}
return num;
}
static int fd_rnd = -1;
static void randombytes(unsigned char *x, unsigned long long xlen)
{
int ret;
if (fd_rnd == -1) {
for (;;) {
fd_rnd = open("/dev/urandom", O_RDONLY);
if (fd_rnd != -1)
break;
sleep(1);
}
}
while (xlen > 0) {
if (xlen < 1048576)
ret = xlen;
else
ret = 1048576;
ret = read(fd_rnd, x, ret);
if (ret < 1) {
sleep(1);
continue;
}
x += ret;
xlen -= ret;
}
}
/* Note: it's not really secure, but the name only suggests it's better to use
* than rand(3) when transferring bytes over the network in non-security
* critical structure members. secrand() is only used to fill up salts actually.
*/
int secrand(void)
{
int ret;
randombytes((void *) &ret, sizeof(ret));
return ret;
}
static char const *priov[] = {
[LOG_EMERG] = "EMERG:",
[LOG_ALERT] = "ALERT:",
[LOG_CRIT] = "CRIT:",
[LOG_ERR] = "ERR:",
[LOG_WARNING] = "WARNING:",
[LOG_NOTICE] = "NOTICE:",
[LOG_INFO] = "INFO:",
[LOG_DEBUG] = "DEBUG:",
};
static ssize_t cookie_writer(void *cookie, char const *data, size_t leng)
{
int prio = LOG_DEBUG, len;
do {
len = strlen(priov[prio]);
} while (memcmp(data, priov[prio], len) && --prio >= 0);
if (prio < 0) {
prio = LOG_INFO;
} else {
data += len;
leng -= len;
}
while (*data == ' ') {
++data;
--leng;
}
syslog(prio, "%.*s", (int) leng, data);
return leng;
}
static cookie_io_functions_t cookie_log = {
.write = cookie_writer,
};
void to_std_log(FILE **fp)
{
setvbuf(*fp = fopencookie(NULL, "w", cookie_log), NULL, _IOLBF, 0);
}
|
