Mark McLoughlin | 1abecf7 | 2009-11-25 18:48:57 +0000 | [diff] [blame] | 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 | |
Peter Maydell | 2744d92 | 2016-01-29 17:50:00 +0000 | [diff] [blame] | 25 | #include "qemu/osdep.h" |
Paolo Bonzini | a245fc1 | 2012-09-17 18:43:51 +0200 | [diff] [blame] | 26 | #include "clients.h" |
Markus Armbruster | da34e65 | 2016-03-14 09:01:28 +0100 | [diff] [blame] | 27 | #include "qapi/error.h" |
Mark McLoughlin | 1abecf7 | 2009-11-25 18:48:57 +0000 | [diff] [blame] | 28 | #include "qemu-common.h" |
Paolo Bonzini | 1de7afc | 2012-12-17 18:20:00 +0100 | [diff] [blame] | 29 | #include "qemu/error-report.h" |
Thomas Huth | 43192fc | 2015-10-13 12:39:58 +0200 | [diff] [blame] | 30 | #include "qemu/iov.h" |
Paolo Bonzini | 1de7afc | 2012-12-17 18:20:00 +0100 | [diff] [blame] | 31 | #include "qemu/log.h" |
| 32 | #include "qemu/timer.h" |
Thomas Huth | 9d3e12e | 2015-10-13 12:40:01 +0200 | [diff] [blame] | 33 | #include "qapi/visitor.h" |
| 34 | #include "net/filter.h" |
Mark McLoughlin | 1abecf7 | 2009-11-25 18:48:57 +0000 | [diff] [blame] | 35 | |
| 36 | typedef struct DumpState { |
Hervé Poussineau | 0fa2991 | 2011-11-30 21:35:38 +0100 | [diff] [blame] | 37 | int64_t start_ts; |
Mark McLoughlin | 1abecf7 | 2009-11-25 18:48:57 +0000 | [diff] [blame] | 38 | int fd; |
| 39 | int pcap_caplen; |
| 40 | } DumpState; |
| 41 | |
| 42 | #define PCAP_MAGIC 0xa1b2c3d4 |
| 43 | |
| 44 | struct pcap_file_hdr { |
| 45 | uint32_t magic; |
| 46 | uint16_t version_major; |
| 47 | uint16_t version_minor; |
| 48 | int32_t thiszone; |
| 49 | uint32_t sigfigs; |
| 50 | uint32_t snaplen; |
| 51 | uint32_t linktype; |
| 52 | }; |
| 53 | |
| 54 | struct pcap_sf_pkthdr { |
| 55 | struct { |
| 56 | int32_t tv_sec; |
| 57 | int32_t tv_usec; |
| 58 | } ts; |
| 59 | uint32_t caplen; |
| 60 | uint32_t len; |
| 61 | }; |
| 62 | |
Thomas Huth | 75310e3 | 2015-10-13 12:40:00 +0200 | [diff] [blame] | 63 | static ssize_t dump_receive_iov(DumpState *s, const struct iovec *iov, int cnt) |
Mark McLoughlin | 1abecf7 | 2009-11-25 18:48:57 +0000 | [diff] [blame] | 64 | { |
Mark McLoughlin | 1abecf7 | 2009-11-25 18:48:57 +0000 | [diff] [blame] | 65 | struct pcap_sf_pkthdr hdr; |
| 66 | int64_t ts; |
| 67 | int caplen; |
Thomas Huth | 43192fc | 2015-10-13 12:39:58 +0200 | [diff] [blame] | 68 | size_t size = iov_size(iov, cnt); |
| 69 | struct iovec dumpiov[cnt + 1]; |
Mark McLoughlin | 1abecf7 | 2009-11-25 18:48:57 +0000 | [diff] [blame] | 70 | |
| 71 | /* Early return in case of previous error. */ |
| 72 | if (s->fd < 0) { |
| 73 | return size; |
| 74 | } |
| 75 | |
Laurent Vivier | ab60b74 | 2015-08-25 17:24:39 +0200 | [diff] [blame] | 76 | ts = qemu_clock_get_us(QEMU_CLOCK_VIRTUAL); |
Mark McLoughlin | 1abecf7 | 2009-11-25 18:48:57 +0000 | [diff] [blame] | 77 | caplen = size > s->pcap_caplen ? s->pcap_caplen : size; |
| 78 | |
Hervé Poussineau | 0fa2991 | 2011-11-30 21:35:38 +0100 | [diff] [blame] | 79 | hdr.ts.tv_sec = ts / 1000000 + s->start_ts; |
Mark McLoughlin | 1abecf7 | 2009-11-25 18:48:57 +0000 | [diff] [blame] | 80 | hdr.ts.tv_usec = ts % 1000000; |
| 81 | hdr.caplen = caplen; |
| 82 | hdr.len = size; |
Thomas Huth | 43192fc | 2015-10-13 12:39:58 +0200 | [diff] [blame] | 83 | |
| 84 | dumpiov[0].iov_base = &hdr; |
| 85 | dumpiov[0].iov_len = sizeof(hdr); |
| 86 | cnt = iov_copy(&dumpiov[1], cnt, iov, cnt, 0, caplen); |
| 87 | |
| 88 | if (writev(s->fd, dumpiov, cnt + 1) != sizeof(hdr) + caplen) { |
Paolo Bonzini | 34f22fc | 2015-12-04 13:38:46 +0100 | [diff] [blame] | 89 | error_report("network dump write error - stopping dump"); |
Mark McLoughlin | 1abecf7 | 2009-11-25 18:48:57 +0000 | [diff] [blame] | 90 | close(s->fd); |
| 91 | s->fd = -1; |
| 92 | } |
| 93 | |
| 94 | return size; |
| 95 | } |
| 96 | |
Thomas Huth | 75310e3 | 2015-10-13 12:40:00 +0200 | [diff] [blame] | 97 | static void dump_cleanup(DumpState *s) |
Thomas Huth | 43192fc | 2015-10-13 12:39:58 +0200 | [diff] [blame] | 98 | { |
Mark McLoughlin | 1abecf7 | 2009-11-25 18:48:57 +0000 | [diff] [blame] | 99 | close(s->fd); |
Thomas Huth | 75310e3 | 2015-10-13 12:40:00 +0200 | [diff] [blame] | 100 | s->fd = -1; |
Mark McLoughlin | 1abecf7 | 2009-11-25 18:48:57 +0000 | [diff] [blame] | 101 | } |
| 102 | |
Thomas Huth | 7bc3074 | 2015-10-13 12:39:59 +0200 | [diff] [blame] | 103 | static int net_dump_state_init(DumpState *s, const char *filename, |
| 104 | int len, Error **errp) |
Mark McLoughlin | 1abecf7 | 2009-11-25 18:48:57 +0000 | [diff] [blame] | 105 | { |
| 106 | struct pcap_file_hdr hdr; |
Hervé Poussineau | 0fa2991 | 2011-11-30 21:35:38 +0100 | [diff] [blame] | 107 | struct tm tm; |
Mark McLoughlin | 731d585 | 2009-11-25 18:49:09 +0000 | [diff] [blame] | 108 | int fd; |
Mark McLoughlin | 1abecf7 | 2009-11-25 18:48:57 +0000 | [diff] [blame] | 109 | |
Hervé Poussineau | 6514ed5 | 2011-11-30 21:35:37 +0100 | [diff] [blame] | 110 | fd = open(filename, O_CREAT | O_TRUNC | O_WRONLY | O_BINARY, 0644); |
Mark McLoughlin | 731d585 | 2009-11-25 18:49:09 +0000 | [diff] [blame] | 111 | if (fd < 0) { |
Thomas Huth | 857d208 | 2018-02-21 11:18:34 +0100 | [diff] [blame] | 112 | error_setg_errno(errp, errno, "net dump: can't open %s", filename); |
Mark McLoughlin | 1abecf7 | 2009-11-25 18:48:57 +0000 | [diff] [blame] | 113 | return -1; |
| 114 | } |
| 115 | |
Mark McLoughlin | 1abecf7 | 2009-11-25 18:48:57 +0000 | [diff] [blame] | 116 | hdr.magic = PCAP_MAGIC; |
| 117 | hdr.version_major = 2; |
| 118 | hdr.version_minor = 4; |
| 119 | hdr.thiszone = 0; |
| 120 | hdr.sigfigs = 0; |
Mark McLoughlin | 731d585 | 2009-11-25 18:49:09 +0000 | [diff] [blame] | 121 | hdr.snaplen = len; |
Mark McLoughlin | 1abecf7 | 2009-11-25 18:48:57 +0000 | [diff] [blame] | 122 | hdr.linktype = 1; |
| 123 | |
Mark McLoughlin | 731d585 | 2009-11-25 18:49:09 +0000 | [diff] [blame] | 124 | if (write(fd, &hdr, sizeof(hdr)) < sizeof(hdr)) { |
Thomas Huth | 857d208 | 2018-02-21 11:18:34 +0100 | [diff] [blame] | 125 | error_setg_errno(errp, errno, "net dump write error"); |
Mark McLoughlin | 731d585 | 2009-11-25 18:49:09 +0000 | [diff] [blame] | 126 | close(fd); |
Mark McLoughlin | 1abecf7 | 2009-11-25 18:48:57 +0000 | [diff] [blame] | 127 | return -1; |
| 128 | } |
| 129 | |
Mark McLoughlin | 731d585 | 2009-11-25 18:49:09 +0000 | [diff] [blame] | 130 | s->fd = fd; |
| 131 | s->pcap_caplen = len; |
| 132 | |
Hervé Poussineau | 0fa2991 | 2011-11-30 21:35:38 +0100 | [diff] [blame] | 133 | qemu_get_timedate(&tm, 0); |
| 134 | s->start_ts = mktime(&tm); |
| 135 | |
Mark McLoughlin | 1abecf7 | 2009-11-25 18:48:57 +0000 | [diff] [blame] | 136 | return 0; |
| 137 | } |
| 138 | |
Thomas Huth | 9d3e12e | 2015-10-13 12:40:01 +0200 | [diff] [blame] | 139 | #define TYPE_FILTER_DUMP "filter-dump" |
| 140 | |
| 141 | #define FILTER_DUMP(obj) \ |
| 142 | OBJECT_CHECK(NetFilterDumpState, (obj), TYPE_FILTER_DUMP) |
| 143 | |
| 144 | struct NetFilterDumpState { |
| 145 | NetFilterState nfs; |
| 146 | DumpState ds; |
| 147 | char *filename; |
| 148 | uint32_t maxlen; |
| 149 | }; |
| 150 | typedef struct NetFilterDumpState NetFilterDumpState; |
| 151 | |
| 152 | static ssize_t filter_dump_receive_iov(NetFilterState *nf, NetClientState *sndr, |
| 153 | unsigned flags, const struct iovec *iov, |
| 154 | int iovcnt, NetPacketSent *sent_cb) |
| 155 | { |
| 156 | NetFilterDumpState *nfds = FILTER_DUMP(nf); |
| 157 | |
| 158 | dump_receive_iov(&nfds->ds, iov, iovcnt); |
| 159 | return 0; |
| 160 | } |
| 161 | |
| 162 | static void filter_dump_cleanup(NetFilterState *nf) |
| 163 | { |
| 164 | NetFilterDumpState *nfds = FILTER_DUMP(nf); |
| 165 | |
| 166 | dump_cleanup(&nfds->ds); |
| 167 | } |
| 168 | |
| 169 | static void filter_dump_setup(NetFilterState *nf, Error **errp) |
| 170 | { |
| 171 | NetFilterDumpState *nfds = FILTER_DUMP(nf); |
| 172 | |
| 173 | if (!nfds->filename) { |
| 174 | error_setg(errp, "dump filter needs 'file' property set!"); |
| 175 | return; |
| 176 | } |
| 177 | |
| 178 | net_dump_state_init(&nfds->ds, nfds->filename, nfds->maxlen, errp); |
| 179 | } |
| 180 | |
Eric Blake | d7bce99 | 2016-01-29 06:48:55 -0700 | [diff] [blame] | 181 | static void filter_dump_get_maxlen(Object *obj, Visitor *v, const char *name, |
| 182 | void *opaque, Error **errp) |
Thomas Huth | 9d3e12e | 2015-10-13 12:40:01 +0200 | [diff] [blame] | 183 | { |
| 184 | NetFilterDumpState *nfds = FILTER_DUMP(obj); |
| 185 | uint32_t value = nfds->maxlen; |
| 186 | |
Eric Blake | 51e72bc | 2016-01-29 06:48:54 -0700 | [diff] [blame] | 187 | visit_type_uint32(v, name, &value, errp); |
Thomas Huth | 9d3e12e | 2015-10-13 12:40:01 +0200 | [diff] [blame] | 188 | } |
| 189 | |
Eric Blake | d7bce99 | 2016-01-29 06:48:55 -0700 | [diff] [blame] | 190 | static void filter_dump_set_maxlen(Object *obj, Visitor *v, const char *name, |
| 191 | void *opaque, Error **errp) |
Thomas Huth | 9d3e12e | 2015-10-13 12:40:01 +0200 | [diff] [blame] | 192 | { |
| 193 | NetFilterDumpState *nfds = FILTER_DUMP(obj); |
| 194 | Error *local_err = NULL; |
| 195 | uint32_t value; |
| 196 | |
Eric Blake | 51e72bc | 2016-01-29 06:48:54 -0700 | [diff] [blame] | 197 | visit_type_uint32(v, name, &value, &local_err); |
Thomas Huth | 9d3e12e | 2015-10-13 12:40:01 +0200 | [diff] [blame] | 198 | if (local_err) { |
| 199 | goto out; |
| 200 | } |
| 201 | if (value == 0) { |
| 202 | error_setg(&local_err, "Property '%s.%s' doesn't take value '%u'", |
| 203 | object_get_typename(obj), name, value); |
| 204 | goto out; |
| 205 | } |
| 206 | nfds->maxlen = value; |
| 207 | |
| 208 | out: |
| 209 | error_propagate(errp, local_err); |
| 210 | } |
| 211 | |
| 212 | static char *file_dump_get_filename(Object *obj, Error **errp) |
| 213 | { |
| 214 | NetFilterDumpState *nfds = FILTER_DUMP(obj); |
| 215 | |
| 216 | return g_strdup(nfds->filename); |
| 217 | } |
| 218 | |
| 219 | static void file_dump_set_filename(Object *obj, const char *value, Error **errp) |
| 220 | { |
| 221 | NetFilterDumpState *nfds = FILTER_DUMP(obj); |
| 222 | |
| 223 | g_free(nfds->filename); |
| 224 | nfds->filename = g_strdup(value); |
| 225 | } |
| 226 | |
| 227 | static void filter_dump_instance_init(Object *obj) |
| 228 | { |
| 229 | NetFilterDumpState *nfds = FILTER_DUMP(obj); |
| 230 | |
| 231 | nfds->maxlen = 65536; |
| 232 | |
Marc-André Lureau | 1e507bb | 2017-06-07 20:36:06 +0400 | [diff] [blame] | 233 | object_property_add(obj, "maxlen", "uint32", filter_dump_get_maxlen, |
Thomas Huth | 9d3e12e | 2015-10-13 12:40:01 +0200 | [diff] [blame] | 234 | filter_dump_set_maxlen, NULL, NULL, NULL); |
| 235 | object_property_add_str(obj, "file", file_dump_get_filename, |
| 236 | file_dump_set_filename, NULL); |
| 237 | } |
| 238 | |
Li Zhijian | b50c7d4 | 2015-12-23 15:43:19 +0800 | [diff] [blame] | 239 | static void filter_dump_instance_finalize(Object *obj) |
| 240 | { |
| 241 | NetFilterDumpState *nfds = FILTER_DUMP(obj); |
| 242 | |
| 243 | g_free(nfds->filename); |
| 244 | } |
| 245 | |
Thomas Huth | 9d3e12e | 2015-10-13 12:40:01 +0200 | [diff] [blame] | 246 | static void filter_dump_class_init(ObjectClass *oc, void *data) |
| 247 | { |
| 248 | NetFilterClass *nfc = NETFILTER_CLASS(oc); |
| 249 | |
| 250 | nfc->setup = filter_dump_setup; |
| 251 | nfc->cleanup = filter_dump_cleanup; |
| 252 | nfc->receive_iov = filter_dump_receive_iov; |
| 253 | } |
| 254 | |
| 255 | static const TypeInfo filter_dump_info = { |
| 256 | .name = TYPE_FILTER_DUMP, |
| 257 | .parent = TYPE_NETFILTER, |
| 258 | .class_init = filter_dump_class_init, |
| 259 | .instance_init = filter_dump_instance_init, |
Li Zhijian | b50c7d4 | 2015-12-23 15:43:19 +0800 | [diff] [blame] | 260 | .instance_finalize = filter_dump_instance_finalize, |
Thomas Huth | 9d3e12e | 2015-10-13 12:40:01 +0200 | [diff] [blame] | 261 | .instance_size = sizeof(NetFilterDumpState), |
| 262 | }; |
| 263 | |
| 264 | static void filter_dump_register_types(void) |
| 265 | { |
| 266 | type_register_static(&filter_dump_info); |
| 267 | } |
| 268 | |
| 269 | type_init(filter_dump_register_types); |