1 | /* |
2 | * QEMU System Emulator |
3 | * |
4 | * Copyright (c) 2003-2008 Fabrice Bellard |
5 | * |
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | * of this software and associated documentation files (the "Software"), to deal |
8 | * in the Software without restriction, including without limitation the rights |
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
10 | * copies of the Software, and to permit persons to whom the Software is |
11 | * furnished to do so, subject to the following conditions: |
12 | * |
13 | * The above copyright notice and this permission notice shall be included in |
14 | * all copies or substantial portions of the Software. |
15 | * |
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
22 | * THE SOFTWARE. |
23 | */ |
24 | |
25 | #include "qemu/osdep.h" |
26 | #include "qemu-common.h" |
27 | #include "clients.h" |
28 | #include "qapi/error.h" |
29 | #include "qemu/error-report.h" |
30 | #include "qemu/iov.h" |
31 | #include "qemu/log.h" |
32 | #include "qemu/module.h" |
33 | #include "qemu/timer.h" |
34 | #include "qapi/visitor.h" |
35 | #include "net/filter.h" |
36 | |
37 | typedef struct DumpState { |
38 | int64_t start_ts; |
39 | int fd; |
40 | int pcap_caplen; |
41 | } DumpState; |
42 | |
43 | #define PCAP_MAGIC 0xa1b2c3d4 |
44 | |
45 | struct pcap_file_hdr { |
46 | uint32_t magic; |
47 | uint16_t version_major; |
48 | uint16_t version_minor; |
49 | int32_t thiszone; |
50 | uint32_t sigfigs; |
51 | uint32_t snaplen; |
52 | uint32_t linktype; |
53 | }; |
54 | |
55 | struct pcap_sf_pkthdr { |
56 | struct { |
57 | int32_t tv_sec; |
58 | int32_t tv_usec; |
59 | } ts; |
60 | uint32_t caplen; |
61 | uint32_t len; |
62 | }; |
63 | |
64 | static ssize_t dump_receive_iov(DumpState *s, const struct iovec *iov, int cnt) |
65 | { |
66 | struct pcap_sf_pkthdr hdr; |
67 | int64_t ts; |
68 | int caplen; |
69 | size_t size = iov_size(iov, cnt); |
70 | struct iovec dumpiov[cnt + 1]; |
71 | |
72 | /* Early return in case of previous error. */ |
73 | if (s->fd < 0) { |
74 | return size; |
75 | } |
76 | |
77 | ts = qemu_clock_get_us(QEMU_CLOCK_VIRTUAL); |
78 | caplen = size > s->pcap_caplen ? s->pcap_caplen : size; |
79 | |
80 | hdr.ts.tv_sec = ts / 1000000 + s->start_ts; |
81 | hdr.ts.tv_usec = ts % 1000000; |
82 | hdr.caplen = caplen; |
83 | hdr.len = size; |
84 | |
85 | dumpiov[0].iov_base = &hdr; |
86 | dumpiov[0].iov_len = sizeof(hdr); |
87 | cnt = iov_copy(&dumpiov[1], cnt, iov, cnt, 0, caplen); |
88 | |
89 | if (writev(s->fd, dumpiov, cnt + 1) != sizeof(hdr) + caplen) { |
90 | error_report("network dump write error - stopping dump" ); |
91 | close(s->fd); |
92 | s->fd = -1; |
93 | } |
94 | |
95 | return size; |
96 | } |
97 | |
98 | static void dump_cleanup(DumpState *s) |
99 | { |
100 | close(s->fd); |
101 | s->fd = -1; |
102 | } |
103 | |
104 | static int net_dump_state_init(DumpState *s, const char *filename, |
105 | int len, Error **errp) |
106 | { |
107 | struct pcap_file_hdr hdr; |
108 | struct tm tm; |
109 | int fd; |
110 | |
111 | fd = open(filename, O_CREAT | O_TRUNC | O_WRONLY | O_BINARY, 0644); |
112 | if (fd < 0) { |
113 | error_setg_errno(errp, errno, "net dump: can't open %s" , filename); |
114 | return -1; |
115 | } |
116 | |
117 | hdr.magic = PCAP_MAGIC; |
118 | hdr.version_major = 2; |
119 | hdr.version_minor = 4; |
120 | hdr.thiszone = 0; |
121 | hdr.sigfigs = 0; |
122 | hdr.snaplen = len; |
123 | hdr.linktype = 1; |
124 | |
125 | if (write(fd, &hdr, sizeof(hdr)) < sizeof(hdr)) { |
126 | error_setg_errno(errp, errno, "net dump write error" ); |
127 | close(fd); |
128 | return -1; |
129 | } |
130 | |
131 | s->fd = fd; |
132 | s->pcap_caplen = len; |
133 | |
134 | qemu_get_timedate(&tm, 0); |
135 | s->start_ts = mktime(&tm); |
136 | |
137 | return 0; |
138 | } |
139 | |
140 | #define TYPE_FILTER_DUMP "filter-dump" |
141 | |
142 | #define FILTER_DUMP(obj) \ |
143 | OBJECT_CHECK(NetFilterDumpState, (obj), TYPE_FILTER_DUMP) |
144 | |
145 | struct NetFilterDumpState { |
146 | NetFilterState nfs; |
147 | DumpState ds; |
148 | char *filename; |
149 | uint32_t maxlen; |
150 | }; |
151 | typedef struct NetFilterDumpState NetFilterDumpState; |
152 | |
153 | static ssize_t filter_dump_receive_iov(NetFilterState *nf, NetClientState *sndr, |
154 | unsigned flags, const struct iovec *iov, |
155 | int iovcnt, NetPacketSent *sent_cb) |
156 | { |
157 | NetFilterDumpState *nfds = FILTER_DUMP(nf); |
158 | |
159 | dump_receive_iov(&nfds->ds, iov, iovcnt); |
160 | return 0; |
161 | } |
162 | |
163 | static void filter_dump_cleanup(NetFilterState *nf) |
164 | { |
165 | NetFilterDumpState *nfds = FILTER_DUMP(nf); |
166 | |
167 | dump_cleanup(&nfds->ds); |
168 | } |
169 | |
170 | static void filter_dump_setup(NetFilterState *nf, Error **errp) |
171 | { |
172 | NetFilterDumpState *nfds = FILTER_DUMP(nf); |
173 | |
174 | if (!nfds->filename) { |
175 | error_setg(errp, "dump filter needs 'file' property set!" ); |
176 | return; |
177 | } |
178 | |
179 | net_dump_state_init(&nfds->ds, nfds->filename, nfds->maxlen, errp); |
180 | } |
181 | |
182 | static void filter_dump_get_maxlen(Object *obj, Visitor *v, const char *name, |
183 | void *opaque, Error **errp) |
184 | { |
185 | NetFilterDumpState *nfds = FILTER_DUMP(obj); |
186 | uint32_t value = nfds->maxlen; |
187 | |
188 | visit_type_uint32(v, name, &value, errp); |
189 | } |
190 | |
191 | static void filter_dump_set_maxlen(Object *obj, Visitor *v, const char *name, |
192 | void *opaque, Error **errp) |
193 | { |
194 | NetFilterDumpState *nfds = FILTER_DUMP(obj); |
195 | Error *local_err = NULL; |
196 | uint32_t value; |
197 | |
198 | visit_type_uint32(v, name, &value, &local_err); |
199 | if (local_err) { |
200 | goto out; |
201 | } |
202 | if (value == 0) { |
203 | error_setg(&local_err, "Property '%s.%s' doesn't take value '%u'" , |
204 | object_get_typename(obj), name, value); |
205 | goto out; |
206 | } |
207 | nfds->maxlen = value; |
208 | |
209 | out: |
210 | error_propagate(errp, local_err); |
211 | } |
212 | |
213 | static char *file_dump_get_filename(Object *obj, Error **errp) |
214 | { |
215 | NetFilterDumpState *nfds = FILTER_DUMP(obj); |
216 | |
217 | return g_strdup(nfds->filename); |
218 | } |
219 | |
220 | static void file_dump_set_filename(Object *obj, const char *value, Error **errp) |
221 | { |
222 | NetFilterDumpState *nfds = FILTER_DUMP(obj); |
223 | |
224 | g_free(nfds->filename); |
225 | nfds->filename = g_strdup(value); |
226 | } |
227 | |
228 | static void filter_dump_instance_init(Object *obj) |
229 | { |
230 | NetFilterDumpState *nfds = FILTER_DUMP(obj); |
231 | |
232 | nfds->maxlen = 65536; |
233 | |
234 | object_property_add(obj, "maxlen" , "uint32" , filter_dump_get_maxlen, |
235 | filter_dump_set_maxlen, NULL, NULL, NULL); |
236 | object_property_add_str(obj, "file" , file_dump_get_filename, |
237 | file_dump_set_filename, NULL); |
238 | } |
239 | |
240 | static void filter_dump_instance_finalize(Object *obj) |
241 | { |
242 | NetFilterDumpState *nfds = FILTER_DUMP(obj); |
243 | |
244 | g_free(nfds->filename); |
245 | } |
246 | |
247 | static void filter_dump_class_init(ObjectClass *oc, void *data) |
248 | { |
249 | NetFilterClass *nfc = NETFILTER_CLASS(oc); |
250 | |
251 | nfc->setup = filter_dump_setup; |
252 | nfc->cleanup = filter_dump_cleanup; |
253 | nfc->receive_iov = filter_dump_receive_iov; |
254 | } |
255 | |
256 | static const TypeInfo filter_dump_info = { |
257 | .name = TYPE_FILTER_DUMP, |
258 | .parent = TYPE_NETFILTER, |
259 | .class_init = filter_dump_class_init, |
260 | .instance_init = filter_dump_instance_init, |
261 | .instance_finalize = filter_dump_instance_finalize, |
262 | .instance_size = sizeof(NetFilterDumpState), |
263 | }; |
264 | |
265 | static void filter_dump_register_types(void) |
266 | { |
267 | type_register_static(&filter_dump_info); |
268 | } |
269 | |
270 | type_init(filter_dump_register_types); |
271 | |