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 "clients.h" 26 #include "qemu-common.h" 27 #include "qemu/error-report.h" 28 #include "qemu/log.h" 29 #include "qemu/timer.h" 30 #include "hub.h" 31 32 typedef struct DumpState { 33 NetClientState nc; 34 int64_t start_ts; 35 int fd; 36 int pcap_caplen; 37 } DumpState; 38 39 #define PCAP_MAGIC 0xa1b2c3d4 40 41 struct pcap_file_hdr { 42 uint32_t magic; 43 uint16_t version_major; 44 uint16_t version_minor; 45 int32_t thiszone; 46 uint32_t sigfigs; 47 uint32_t snaplen; 48 uint32_t linktype; 49 }; 50 51 struct pcap_sf_pkthdr { 52 struct { 53 int32_t tv_sec; 54 int32_t tv_usec; 55 } ts; 56 uint32_t caplen; 57 uint32_t len; 58 }; 59 60 static ssize_t dump_receive(NetClientState *nc, const uint8_t *buf, size_t size) 61 { 62 DumpState *s = DO_UPCAST(DumpState, nc, nc); 63 struct pcap_sf_pkthdr hdr; 64 int64_t ts; 65 int caplen; 66 67 /* Early return in case of previous error. */ 68 if (s->fd < 0) { 69 return size; 70 } 71 72 ts = muldiv64(qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL), 1000000, get_ticks_per_sec()); 73 caplen = size > s->pcap_caplen ? s->pcap_caplen : size; 74 75 hdr.ts.tv_sec = ts / 1000000 + s->start_ts; 76 hdr.ts.tv_usec = ts % 1000000; 77 hdr.caplen = caplen; 78 hdr.len = size; 79 if (write(s->fd, &hdr, sizeof(hdr)) != sizeof(hdr) || 80 write(s->fd, buf, caplen) != caplen) { 81 qemu_log("-net dump write error - stop dump\n"); 82 close(s->fd); 83 s->fd = -1; 84 } 85 86 return size; 87 } 88 89 static void dump_cleanup(NetClientState *nc) 90 { 91 DumpState *s = DO_UPCAST(DumpState, nc, nc); 92 93 close(s->fd); 94 } 95 96 static NetClientInfo net_dump_info = { 97 .type = NET_CLIENT_OPTIONS_KIND_DUMP, 98 .size = sizeof(DumpState), 99 .receive = dump_receive, 100 .cleanup = dump_cleanup, 101 }; 102 103 static int net_dump_init(NetClientState *peer, const char *device, 104 const char *name, const char *filename, int len, 105 Error **errp) 106 { 107 struct pcap_file_hdr hdr; 108 NetClientState *nc; 109 DumpState *s; 110 struct tm tm; 111 int fd; 112 113 fd = open(filename, O_CREAT | O_TRUNC | O_WRONLY | O_BINARY, 0644); 114 if (fd < 0) { 115 error_setg_errno(errp, errno, "-net dump: can't open %s", filename); 116 return -1; 117 } 118 119 hdr.magic = PCAP_MAGIC; 120 hdr.version_major = 2; 121 hdr.version_minor = 4; 122 hdr.thiszone = 0; 123 hdr.sigfigs = 0; 124 hdr.snaplen = len; 125 hdr.linktype = 1; 126 127 if (write(fd, &hdr, sizeof(hdr)) < sizeof(hdr)) { 128 error_setg_errno(errp, errno, "-net dump write error"); 129 close(fd); 130 return -1; 131 } 132 133 nc = qemu_new_net_client(&net_dump_info, peer, device, name); 134 135 snprintf(nc->info_str, sizeof(nc->info_str), 136 "dump to %s (len=%d)", filename, len); 137 138 s = DO_UPCAST(DumpState, nc, nc); 139 140 s->fd = fd; 141 s->pcap_caplen = len; 142 143 qemu_get_timedate(&tm, 0); 144 s->start_ts = mktime(&tm); 145 146 return 0; 147 } 148 149 int net_init_dump(const NetClientOptions *opts, const char *name, 150 NetClientState *peer, Error **errp) 151 { 152 int len; 153 const char *file; 154 char def_file[128]; 155 const NetdevDumpOptions *dump; 156 157 assert(opts->kind == NET_CLIENT_OPTIONS_KIND_DUMP); 158 dump = opts->dump; 159 160 assert(peer); 161 162 if (dump->has_file) { 163 file = dump->file; 164 } else { 165 int id; 166 int ret; 167 168 ret = net_hub_id_for_client(peer, &id); 169 assert(ret == 0); /* peer must be on a hub */ 170 171 snprintf(def_file, sizeof(def_file), "qemu-vlan%d.pcap", id); 172 file = def_file; 173 } 174 175 if (dump->has_len) { 176 if (dump->len > INT_MAX) { 177 error_setg(errp, "invalid length: %"PRIu64, dump->len); 178 return -1; 179 } 180 len = dump->len; 181 } else { 182 len = 65536; 183 } 184 185 return net_dump_init(peer, "dump", name, file, len, errp); 186 } 187