]>
Commit | Line | Data |
---|---|---|
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 | uint32_t value; | |
196 | ||
197 | if (!visit_type_uint32(v, name, &value, errp)) { | |
198 | return; | |
199 | } | |
200 | if (value == 0) { | |
201 | error_setg(errp, "Property '%s.%s' doesn't take value '%u'", | |
202 | object_get_typename(obj), name, value); | |
203 | return; | |
204 | } | |
205 | nfds->maxlen = value; | |
206 | } | |
207 | ||
208 | static char *file_dump_get_filename(Object *obj, Error **errp) | |
209 | { | |
210 | NetFilterDumpState *nfds = FILTER_DUMP(obj); | |
211 | ||
212 | return g_strdup(nfds->filename); | |
213 | } | |
214 | ||
215 | static void file_dump_set_filename(Object *obj, const char *value, Error **errp) | |
216 | { | |
217 | NetFilterDumpState *nfds = FILTER_DUMP(obj); | |
218 | ||
219 | g_free(nfds->filename); | |
220 | nfds->filename = g_strdup(value); | |
221 | } | |
222 | ||
223 | static void filter_dump_instance_init(Object *obj) | |
224 | { | |
225 | NetFilterDumpState *nfds = FILTER_DUMP(obj); | |
226 | ||
227 | nfds->maxlen = 65536; | |
228 | ||
229 | object_property_add(obj, "maxlen", "uint32", filter_dump_get_maxlen, | |
230 | filter_dump_set_maxlen, NULL, NULL); | |
231 | object_property_add_str(obj, "file", file_dump_get_filename, | |
232 | file_dump_set_filename); | |
233 | } | |
234 | ||
235 | static void filter_dump_instance_finalize(Object *obj) | |
236 | { | |
237 | NetFilterDumpState *nfds = FILTER_DUMP(obj); | |
238 | ||
239 | g_free(nfds->filename); | |
240 | } | |
241 | ||
242 | static void filter_dump_class_init(ObjectClass *oc, void *data) | |
243 | { | |
244 | NetFilterClass *nfc = NETFILTER_CLASS(oc); | |
245 | ||
246 | nfc->setup = filter_dump_setup; | |
247 | nfc->cleanup = filter_dump_cleanup; | |
248 | nfc->receive_iov = filter_dump_receive_iov; | |
249 | } | |
250 | ||
251 | static const TypeInfo filter_dump_info = { | |
252 | .name = TYPE_FILTER_DUMP, | |
253 | .parent = TYPE_NETFILTER, | |
254 | .class_init = filter_dump_class_init, | |
255 | .instance_init = filter_dump_instance_init, | |
256 | .instance_finalize = filter_dump_instance_finalize, | |
257 | .instance_size = sizeof(NetFilterDumpState), | |
258 | }; | |
259 | ||
260 | static void filter_dump_register_types(void) | |
261 | { | |
262 | type_register_static(&filter_dump_info); | |
263 | } | |
264 | ||
265 | type_init(filter_dump_register_types); |