Line data Source code
1 : /*
2 : * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
3 : */
4 :
5 : #include "base/os.h"
6 : #include <netinet/icmp6.h>
7 : #include <boost/assign/list_of.hpp>
8 : #include <pkt/pkt_handler.h>
9 : #include <oper/mirror_table.h>
10 : #include <oper/vn.h>
11 : #include <pkt/pkt_init.h>
12 : #include <services/services_init.h>
13 : #include <services/dhcp_proto.h>
14 : #include <services/dhcpv6_proto.h>
15 : #include <services/arp_proto.h>
16 : #include <services/bfd_proto.h>
17 : #include <services/dns_proto.h>
18 : #include <services/icmp_proto.h>
19 : #include <services/igmp_proto.h>
20 : #include <services/icmpv6_proto.h>
21 : #include <services/metadata_proxy.h>
22 : #include <services/services_types.h>
23 : #include <services/services_sandesh.h>
24 : #include <bind/bind_resolver.h>
25 : #include <vr_defs.h>
26 :
27 : #define SET_ICMPV6_INTERFACE_STATS(it, list) \
28 : InterfaceIcmpv6Stats entry; \
29 : VmInterface *vmi = it->first; \
30 : const Icmpv6Proto::Icmpv6Stats &stats = it->second; \
31 : entry.set_interface_index(vmi->id()); \
32 : entry.set_icmpv6_router_solicit(stats.icmpv6_router_solicit_); \
33 : entry.set_icmpv6_router_advert(stats.icmpv6_router_advert_); \
34 : entry.set_icmpv6_ping_request(stats.icmpv6_ping_request_); \
35 : entry.set_icmpv6_ping_response(stats.icmpv6_ping_response_); \
36 : entry.set_icmpv6_neighbor_solicit(stats.icmpv6_neighbor_solicit_); \
37 : entry.set_icmpv6_neighbor_solicited(stats.icmpv6_neighbor_solicited_); \
38 : entry.set_icmpv6_neighbor_advert_solicited \
39 : (stats.icmpv6_neighbor_advert_solicited_); \
40 : entry.set_icmpv6_neighbor_advert_unsolicited \
41 : (stats.icmpv6_neighbor_advert_unsolicited_); \
42 : list.push_back(entry);
43 :
44 : std::map<uint16_t, std::string> g_ip_protocol_map =
45 : boost::assign::map_list_of<uint16_t, std::string>
46 : (1, "icmp")
47 : (2, "igmp")
48 : (4, "ipv4")
49 : (6, "tcp")
50 : (17, "udp")
51 : (41, "ipv6")
52 : (47, "gre");
53 :
54 : std::map<uint32_t, std::string> g_dhcp_msg_types =
55 : boost::assign::map_list_of<uint32_t, std::string>
56 : (DHCP_UNKNOWN, "Unknown")
57 : (DHCP_DISCOVER, "Discover")
58 : (DHCP_OFFER, "Offer")
59 : (DHCP_REQUEST, "Request")
60 : (DHCP_ACK, "Ack")
61 : (DHCP_NAK, "Nack")
62 : (DHCP_INFORM, "Inform")
63 : (DHCP_DECLINE, "Decline")
64 : (DHCP_RELEASE, "Release")
65 : (DHCP_LEASE_QUERY, "Lease Query")
66 : (DHCP_LEASE_UNASSIGNED, "Lease Unassigned")
67 : (DHCP_LEASE_UNKNOWN, "Lease Unknown")
68 : (DHCP_LEASE_ACTIVE, "Lease Active");
69 :
70 : std::map<uint32_t, std::string> g_dhcpv6_msg_types =
71 : boost::assign::map_list_of<uint32_t, std::string>
72 : (DHCPV6_UNKNOWN, "Unknown")
73 : (DHCPV6_SOLICIT, "Solicit")
74 : (DHCPV6_ADVERTISE, "Advertise")
75 : (DHCPV6_REQUEST, "Request")
76 : (DHCPV6_CONFIRM, "Confirm")
77 : (DHCPV6_RENEW, "Renew")
78 : (DHCPV6_REBIND, "Rebind")
79 : (DHCPV6_REPLY, "Reply")
80 : (DHCPV6_RELEASE, "Release")
81 : (DHCPV6_DECLINE, "Decline")
82 : (DHCPV6_RECONFIGURE, "Reconfigure")
83 : (DHCPV6_INFORMATION_REQUEST, "Information Request");
84 :
85 0 : void ServicesSandesh::MacToString(const unsigned char *mac, std::string &mac_str) {
86 : char mstr[32];
87 0 : snprintf(mstr, 32, "%02x:%02x:%02x:%02x:%02x:%02x",
88 0 : mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
89 0 : mac_str.assign(mstr);
90 0 : }
91 :
92 0 : std::string ServicesSandesh::IntToString(uint32_t val) {
93 0 : std::ostringstream str;
94 0 : str << val;
95 0 : return str.str();
96 0 : }
97 :
98 0 : std::string ServicesSandesh::IntToHexString(uint32_t val) {
99 0 : std::ostringstream str;
100 0 : str << "0x" << std::hex << val;
101 0 : return str.str();
102 0 : }
103 :
104 0 : void ServicesSandesh::PktToHexString(uint8_t *pkt, int32_t len,
105 : std::string &msg) {
106 0 : for (int32_t i = 0; i < len; i++) {
107 : char val[4];
108 0 : snprintf(val, 4, "%02x ", pkt[i]);
109 0 : msg.append(val);
110 : }
111 0 : }
112 :
113 0 : std::string ServicesSandesh::IpProtocol(uint16_t prot) {
114 0 : std::map<uint16_t, std::string>::iterator it = g_ip_protocol_map.find(prot);
115 0 : if (it == g_ip_protocol_map.end()) {
116 0 : return IntToString(prot);
117 : }
118 0 : return it->second;
119 : }
120 :
121 0 : std::string &ServicesSandesh::DhcpMsgType(uint32_t msg_type) {
122 0 : std::map<uint32_t, std::string>::iterator it = g_dhcp_msg_types.find(msg_type);
123 0 : if (it == g_dhcp_msg_types.end())
124 0 : return DhcpMsgType(DHCP_UNKNOWN);
125 0 : return it->second;
126 : }
127 :
128 0 : std::string &ServicesSandesh::Dhcpv6MsgType(uint32_t msg_type) {
129 0 : std::map<uint32_t, std::string>::iterator it = g_dhcpv6_msg_types.find(msg_type);
130 0 : if (it == g_dhcpv6_msg_types.end())
131 0 : return Dhcpv6MsgType(DHCPV6_OPTION_UNKNOWN);
132 0 : return it->second;
133 : }
134 :
135 0 : void ServicesSandesh::PktStatsSandesh(std::string ctxt, bool more) {
136 0 : PktStats *resp = new PktStats();
137 0 : const PktHandler::PktStats &stats = Agent::GetInstance()->pkt()->pkt_handler()->GetStats();
138 0 : uint32_t total_rcvd = 0;
139 0 : uint32_t total_sent = 0;
140 0 : for (int i = 0; i < PktHandler::MAX_MODULES; ++i) {
141 0 : total_rcvd += stats.received[i];
142 0 : total_sent += stats.sent[i];
143 : }
144 0 : resp->set_total_rcvd(total_rcvd);
145 0 : resp->set_dhcp_rcvd(stats.received[PktHandler::DHCP]);
146 0 : resp->set_arp_rcvd(stats.received[PktHandler::ARP]);
147 0 : resp->set_dns_rcvd(stats.received[PktHandler::DNS]);
148 0 : resp->set_icmp_rcvd(stats.received[PktHandler::ICMP]);
149 0 : resp->set_flow_rcvd(stats.received[PktHandler::FLOW]);
150 0 : resp->set_mac_learning_msg_rcvd(stats.received[PktHandler::MAC_LEARNING]);
151 0 : resp->set_dropped(stats.dropped);
152 0 : resp->set_total_sent(total_sent);
153 0 : resp->set_dhcp_sent(stats.sent[PktHandler::DHCP]);
154 0 : resp->set_arp_sent(stats.sent[PktHandler::ARP]);
155 0 : resp->set_dns_sent(stats.sent[PktHandler::DNS]);
156 0 : resp->set_icmp_sent(stats.sent[PktHandler::ICMP]);
157 0 : resp->set_dhcp_q_threshold_exceeded(stats.q_threshold_exceeded[PktHandler::DHCP]);
158 0 : resp->set_arp_q_threshold_exceeded(stats.q_threshold_exceeded[PktHandler::ARP]);
159 0 : resp->set_dns_q_threshold_exceeded(stats.q_threshold_exceeded[PktHandler::DNS]);
160 0 : resp->set_icmp_q_threshold_exceeded(stats.q_threshold_exceeded[PktHandler::ICMP]);
161 0 : resp->set_flow_q_threshold_exceeded(stats.q_threshold_exceeded[PktHandler::FLOW]);
162 0 : resp->set_context(ctxt);
163 0 : resp->set_more(more);
164 0 : resp->Response();
165 0 : }
166 :
167 0 : void ServicesSandesh::DhcpStatsSandesh(std::string ctxt, bool more) {
168 0 : DhcpStats *dhcp = new DhcpStats();
169 : const DhcpProto::DhcpStats &dstats =
170 0 : Agent::GetInstance()->GetDhcpProto()->GetStats();
171 0 : dhcp->set_dhcp_discover(dstats.discover);
172 0 : dhcp->set_dhcp_request(dstats.request);
173 0 : dhcp->set_dhcp_inform(dstats.inform);
174 0 : dhcp->set_dhcp_decline(dstats.decline);
175 0 : dhcp->set_dhcp_other(dstats.other);
176 0 : dhcp->set_dhcp_errors(dstats.errors);
177 0 : dhcp->set_offers_sent(dstats.offers);
178 0 : dhcp->set_acks_sent(dstats.acks);
179 0 : dhcp->set_nacks_sent(dstats.nacks);
180 0 : dhcp->set_relay_request(dstats.relay_req);
181 0 : dhcp->set_relay_response(dstats.relay_resp);
182 0 : dhcp->set_unknown_msg_drop(dstats.unknown_msg_drop);
183 0 : dhcp->set_dhcp_disabled_drop(dstats.dhcp_disabled_drop);
184 0 : dhcp->set_incorrect_mac(dstats.incorrect_mac);
185 0 : dhcp->set_context(ctxt);
186 0 : dhcp->set_more(more);
187 0 : dhcp->Response();
188 0 : }
189 :
190 0 : void ServicesSandesh::Dhcpv6StatsSandesh(std::string ctxt, bool more) {
191 0 : Dhcpv6Stats *dhcp = new Dhcpv6Stats();
192 : const Dhcpv6Proto::DhcpStats &dstats =
193 0 : Agent::GetInstance()->dhcpv6_proto()->GetStats();
194 0 : dhcp->set_dhcp_solicit(dstats.solicit);
195 0 : dhcp->set_dhcp_advertise(dstats.advertise);
196 0 : dhcp->set_dhcp_request(dstats.request);
197 0 : dhcp->set_dhcp_confirm(dstats.confirm);
198 0 : dhcp->set_dhcp_renew(dstats.renew);
199 0 : dhcp->set_dhcp_rebind(dstats.rebind);
200 0 : dhcp->set_dhcp_reply(dstats.reply);
201 0 : dhcp->set_dhcp_release(dstats.release);
202 0 : dhcp->set_dhcp_decline(dstats.decline);
203 0 : dhcp->set_dhcp_reconfigure(dstats.reconfigure);
204 0 : dhcp->set_information_request(dstats.information_request);
205 0 : dhcp->set_dhcp_error(dstats.error);
206 0 : dhcp->set_context(ctxt);
207 0 : dhcp->set_more(more);
208 0 : dhcp->Response();
209 0 : }
210 :
211 0 : void ServicesSandesh::ArpStatsSandesh(std::string ctxt, bool more) {
212 0 : ArpProto *arp_proto = Agent::GetInstance()->GetArpProto();
213 0 : ArpStats *arp = new ArpStats();
214 0 : const ArpProto::ArpStats &astats = arp_proto->GetStats();
215 0 : arp->set_arp_entries(arp_proto->GetArpCacheSize());
216 0 : arp->set_arp_requests(astats.arp_req);
217 0 : arp->set_arp_replies(astats.arp_replies);
218 0 : arp->set_arp_gratuitous(astats.arp_gratuitous);
219 0 : arp->set_arp_resolved(astats.resolved);
220 0 : arp->set_arp_max_retries_exceeded(astats.max_retries_exceeded);
221 0 : arp->set_arp_errors(astats.errors);
222 0 : arp->set_arp_invalid_packets(astats.arp_invalid_packets);
223 0 : arp->set_arp_invalid_interface(astats.arp_invalid_interface);
224 0 : arp->set_arp_invalid_vrf(astats.arp_invalid_vrf);
225 0 : arp->set_arp_invalid_address(astats.arp_invalid_address);
226 0 : arp->set_context(ctxt);
227 0 : arp->set_more(more);
228 0 : arp->Response();
229 0 : }
230 :
231 0 : void ServicesSandesh::BfdStatsSandesh(std::string ctxt, bool more) {
232 0 : BfdProto *bfd_proto = Agent::GetInstance()->GetBfdProto();
233 0 : BfdStats *bfd = new BfdStats();
234 0 : const BfdProto::BfdStats &stats = bfd_proto->GetStats();
235 0 : bfd->set_bfd_sent(stats.bfd_sent);
236 0 : bfd->set_bfd_received(stats.bfd_received);
237 0 : bfd->set_bfd_receive_drop_count(stats.bfd_rx_drop_count);
238 0 : bfd->set_bfd_receive_ka_enqueue_count(stats.bfd_rx_ka_enqueue_count);
239 0 : bfd->set_bfd_active_sessions(bfd_proto->ActiveSessions());
240 :
241 : std::vector<BfdSandeshSessions> &bfd_list =
242 0 : const_cast<std::vector<BfdSandeshSessions>&>(bfd->get_bfd_sessions());
243 0 : BFD::Server *server = bfd_proto->bfd_communicator().GetServer();
244 0 : BFD::Sessions *sessions = server->GetSessions();
245 0 : BFD::Sessions::iterator it = sessions->begin();
246 0 : while (it != sessions->end()) {
247 0 : BFD::SessionKey key = *it;
248 0 : BfdSandeshSessions session;
249 0 : session.local_address = key.local_address.to_string();
250 0 : session.remote_address = key.remote_address.to_string();
251 0 : session.index = key.index.to_string();
252 0 : session.remote_port = key.remote_port;
253 :
254 0 : BFD::Session *bfd_session = server->SessionByKey(key);
255 0 : std::ostringstream ss, rem_ss;
256 0 : ss << bfd_session->local_state();
257 0 : session.local_status = ss.str();
258 0 : rem_ss << bfd_session->remote_state().state;
259 0 : session.remote_status = rem_ss.str();
260 :
261 0 : session.stats.rx_count = bfd_session->Stats().rx_count;
262 0 : session.stats.tx_count = bfd_session->Stats().tx_count;
263 0 : session.stats.rx_error_count = bfd_session->Stats().rx_error_count;
264 0 : session.stats.tx_error_count = bfd_session->Stats().tx_error_count;
265 0 : session.stats.receive_timer_expired_count =
266 0 : bfd_session->Stats().receive_timer_expired_count;
267 0 : session.stats.send_timer_expired_count =
268 0 : bfd_session->Stats().send_timer_expired_count;
269 :
270 0 : bfd_list.push_back(session);
271 0 : it++;
272 0 : }
273 :
274 0 : bfd->set_context(ctxt);
275 0 : bfd->set_more(more);
276 0 : bfd->Response();
277 0 : }
278 :
279 0 : void ServicesSandesh::DnsStatsSandesh(std::string ctxt, bool more) {
280 0 : DnsStats *dns = new DnsStats();
281 0 : const DnsProto::DnsStats &nstats = Agent::GetInstance()->GetDnsProto()->GetStats();
282 0 : uint8_t count = 0;
283 : std::vector<string> &list =
284 0 : const_cast<std::vector<string>&>(dns->get_dns_resolver());
285 :
286 0 : std::vector<string>dns_servers;
287 0 : uint8_t resolver_count = Agent::GetInstance()->GetDnslist().size();
288 0 : while (count < resolver_count) {
289 0 : boost::split(dns_servers, Agent::GetInstance()->GetDnslist()[count],
290 0 : boost::is_any_of(":"));
291 0 : list.push_back(dns_servers[0]);
292 0 : count++;
293 : }
294 :
295 0 : BindResolver *resolv = BindResolver::Resolver();
296 0 : uint16_t dscp = 0;
297 0 : if (resolv) {
298 0 : dscp = resolv->GetDscpValue();
299 : }
300 0 : dns->set_dscp(dscp);
301 :
302 0 : dns->set_dns_requests(nstats.requests);
303 0 : dns->set_dns_resolved(nstats.resolved);
304 0 : dns->set_dns_retransmit_reqs(nstats.retransmit_reqs);
305 0 : dns->set_dns_unsupported(nstats.unsupported);
306 0 : dns->set_dns_failures(nstats.fail);
307 0 : dns->set_dns_drops(nstats.drop);
308 0 : dns->set_context(ctxt);
309 0 : dns->set_more(more);
310 0 : dns->Response();
311 0 : }
312 :
313 0 : void ServicesSandesh::IcmpStatsSandesh(std::string ctxt, bool more) {
314 0 : IcmpStats *icmp = new IcmpStats();
315 0 : const IcmpProto::IcmpStats &istats = Agent::GetInstance()->GetIcmpProto()->GetStats();
316 0 : icmp->set_icmp_gw_ping(istats.icmp_gw_ping);
317 0 : icmp->set_icmp_gw_ping_err(istats.icmp_gw_ping_err);
318 0 : icmp->set_icmp_drop(istats.icmp_drop);
319 0 : icmp->set_context(ctxt);
320 0 : icmp->set_more(more);
321 0 : icmp->Response();
322 0 : }
323 :
324 0 : void ServicesSandesh::Icmpv6StatsSandesh(std::string ctxt, bool more) {
325 0 : Icmpv6Stats *icmp = new Icmpv6Stats();
326 : const Icmpv6Proto::Icmpv6Stats &istats =
327 0 : Agent::GetInstance()->icmpv6_proto()->GetStats();
328 0 : icmp->set_icmpv6_router_solicit(istats.icmpv6_router_solicit_);
329 0 : icmp->set_icmpv6_router_advert(istats.icmpv6_router_advert_);
330 0 : icmp->set_icmpv6_ping_request(istats.icmpv6_ping_request_);
331 0 : icmp->set_icmpv6_ping_response(istats.icmpv6_ping_response_);
332 0 : icmp->set_icmpv6_drop(istats.icmpv6_drop_);
333 0 : icmp->set_icmpv6_neighbor_solicit(istats.icmpv6_neighbor_solicit_);
334 0 : icmp->set_icmpv6_neighbor_solicited(istats.icmpv6_neighbor_solicited_);
335 : icmp->set_icmpv6_neighbor_advert_solicited
336 0 : (istats.icmpv6_neighbor_advert_solicited_);
337 : icmp->set_icmpv6_neighbor_advert_unsolicited
338 0 : (istats.icmpv6_neighbor_advert_unsolicited_);
339 0 : icmp->set_context(ctxt);
340 0 : icmp->set_more(more);
341 0 : icmp->Response();
342 0 : }
343 :
344 0 : void ServicesSandesh::IgmpStatsSandesh(std::string ctxt, bool more) {
345 0 : IgmpStatsResponse *igmp = new IgmpStatsResponse();
346 0 : const IgmpProto::IgmpStats &istats = Agent::GetInstance()->GetIgmpProto()->GetStats();
347 0 : igmp->set_bad_length(istats.bad_length);
348 0 : igmp->set_bad_cksum(istats.bad_cksum);
349 0 : igmp->set_bad_interface(istats.bad_interface);
350 0 : igmp->set_not_local(istats.not_local);
351 0 : igmp->set_rx_unknown(istats.rx_unknown);
352 0 : igmp->set_rejected_pkt(istats.rejected_pkt);
353 0 : igmp->set_context(ctxt);
354 0 : igmp->set_more(more);
355 0 : igmp->Response();
356 0 : }
357 :
358 0 : void ServicesSandesh::FillPktData(PktTrace::Pkt &pkt, PktData &resp) {
359 0 : switch (pkt.dir) {
360 0 : case PktTrace::In:
361 0 : resp.direction = "in";
362 0 : break;
363 0 : case PktTrace::Out:
364 0 : resp.direction = "out";
365 0 : break;
366 0 : default:
367 0 : resp.direction = "error";
368 0 : break;
369 : }
370 0 : resp.len = pkt.len;
371 0 : }
372 :
373 0 : uint16_t ServicesSandesh::FillVrouterHdr(PktTrace::Pkt &pkt, VrouterHdr &resp) {
374 : boost::array<std::string, MAX_AGENT_HDR_COMMANDS> commands =
375 : { { "switch", "route", "arp", "l2-protocol", "trap-nexthop",
376 : "trap-resolve", "trap-flow-miss", "trap-l3-protocol",
377 : "trap-diag", "trap-ecmp-resolve", "trap_source_mismatch",
378 : "trap-dont-fragment", "trap-zero-ttl", "tor-control",
379 : "trap-icmp-error", "trap-flow-hold-action",
380 0 : "trap-route-alert", "trap-mac-learn", "trap-mac-move" } };
381 0 : uint8_t *ptr = pkt.pkt;
382 0 : AgentHdr *hdr = reinterpret_cast<AgentHdr *>(ptr);
383 0 : resp.ifindex = hdr->ifindex;
384 0 : resp.vrf = hdr->vrf;
385 0 : uint16_t cmd = hdr->cmd;
386 0 : if (cmd < MAX_AGENT_HDR_COMMANDS)
387 0 : resp.cmd = commands.at(cmd);
388 : else
389 0 : resp.cmd = "unknown";
390 0 : resp.cmd_param = hdr->cmd_param;
391 0 : resp.nh = hdr->nh;
392 0 : return sizeof(AgentHdr);
393 0 : }
394 :
395 0 : int ServicesSandesh::FillMacHdr(struct ether_header *eth, MacHdr &resp) {
396 0 : int len = sizeof(struct ether_header);
397 0 : MacToString(eth->ether_dhost, resp.dest_mac);
398 0 : MacToString(eth->ether_shost, resp.src_mac);
399 0 : uint16_t type = ntohs(eth->ether_type);
400 0 : uint8_t *ptr = (uint8_t *)eth + 12;
401 0 : while (type == ETHERTYPE_VLAN) {
402 0 : len += 4;
403 0 : ptr += 4;
404 0 : type = ntohs(*(uint16_t *)ptr);
405 : }
406 0 : resp.type = (type == 0x800) ? "ip" :
407 0 : (type == 0x806) ? "arp" : IntToString(type);
408 0 : return len;
409 : }
410 :
411 0 : static uint32_t get_val(void *data) {
412 : union {
413 : uint8_t data[sizeof(uint32_t)];
414 : uint32_t addr;
415 : } bytes;
416 0 : memcpy(bytes.data, data, sizeof(uint32_t));
417 0 : return ntohl(bytes.addr);
418 : }
419 :
420 0 : void ServicesSandesh::FillArpHdr(ether_arp *arp, ArpHdr &resp) {
421 0 : uint16_t val = ntohs(arp->arp_hrd);
422 0 : resp.htype = (val == 1) ? "ethernet" : IntToString(val);
423 0 : val = ntohs(arp->arp_pro);
424 0 : resp.protocol = (val == 0x800) ? "ip" : IntToString(val);
425 0 : resp.hw_size = arp->arp_hln;
426 0 : resp.prot_size = arp->arp_pln;
427 0 : val = ntohs(arp->arp_op);
428 0 : resp.opcode = (val == 1) ? "request" :
429 0 : (val == 2) ? "response" : IntToString(val);
430 0 : MacToString(arp->arp_sha, resp.sender_mac);
431 0 : MacToString(arp->arp_tha, resp.target_mac);
432 0 : Ip4Address spa(get_val(arp->arp_spa));
433 0 : Ip4Address tpa(get_val(arp->arp_tpa));
434 0 : resp.sender_ip = spa.to_string();
435 0 : resp.target_ip = tpa.to_string();
436 0 : }
437 :
438 0 : void ServicesSandesh::FillIpv4Hdr(struct ip *ip, Ipv4Hdr &resp) {
439 0 : resp.vers = ip->ip_v;
440 0 : resp.hdrlen = ip->ip_hl;
441 0 : resp.tos = ip->ip_tos;
442 0 : resp.len = ntohs(ip->ip_len);
443 0 : resp.id = IntToHexString(ntohs(ip->ip_id));
444 0 : resp.frag = IntToHexString(ntohs(ip->ip_off));
445 0 : resp.ttl = ip->ip_ttl;
446 0 : resp.protocol = IpProtocol(ip->ip_p);
447 0 : resp.csum = IntToHexString(ntohs(ip->ip_sum));
448 0 : Ip4Address sa(ntohl(ip->ip_src.s_addr));
449 0 : Ip4Address da(ntohl(ip->ip_dst.s_addr));
450 0 : resp.src_ip = sa.to_string();
451 0 : resp.dest_ip = da.to_string();
452 0 : }
453 :
454 0 : void ServicesSandesh::FillIpv6Hdr(ip6_hdr *ip, Ipv6Hdr &resp) {
455 0 : resp.flow = ntohl(ip->ip6_flow);
456 0 : resp.plen = ntohs(ip->ip6_plen);
457 0 : resp.next_hdr = ip->ip6_nxt;
458 0 : resp.hlim = ip->ip6_hlim;
459 :
460 0 : boost::system::error_code ec;
461 : boost::asio::ip::address_v6::bytes_type src_addr;
462 0 : memcpy(&src_addr[0], ip->ip6_src.s6_addr, 16);
463 0 : boost::asio::ip::address_v6 src(src_addr);
464 0 : resp.src_ip = src.to_string(ec);
465 :
466 : boost::asio::ip::address_v6::bytes_type dest_addr;
467 0 : memcpy(&dest_addr[0], ip->ip6_dst.s6_addr, 16);
468 0 : boost::asio::ip::address_v6 dest(dest_addr);
469 0 : resp.dest_ip = dest.to_string(ec);
470 0 : }
471 :
472 0 : void ServicesSandesh::FillIcmpv4Hdr(struct icmp *icmp, Icmpv4Hdr &resp) {
473 0 : resp.type = (icmp->icmp_type == ICMP_ECHO) ? "echo request":
474 0 : (icmp->icmp_type == ICMP_ECHOREPLY) ? "echo reply" :
475 0 : IntToString(icmp->icmp_type);
476 0 : resp.code = icmp->icmp_code;
477 0 : resp.csum = IntToHexString(ntohs(icmp->icmp_cksum));
478 0 : }
479 :
480 0 : void ServicesSandesh::FillIcmpv6Hdr(icmp6_hdr *icmp, Icmpv6Hdr &resp,
481 : int32_t len) {
482 0 : switch (icmp->icmp6_type) {
483 0 : case ICMP6_ECHO_REQUEST:
484 0 : resp.type = "echo request";
485 0 : break;
486 :
487 0 : case ICMP6_ECHO_REPLY:
488 0 : resp.type = "echo reply";
489 0 : break;
490 :
491 0 : case ND_ROUTER_SOLICIT:
492 0 : resp.type = "router solicit";
493 0 : break;
494 :
495 0 : case ND_ROUTER_ADVERT:
496 0 : resp.type = "router advertisement";
497 0 : break;
498 :
499 0 : default:
500 0 : resp.type = IntToString(icmp->icmp6_type);
501 0 : break;
502 : }
503 0 : resp.code = icmp->icmp6_code;
504 0 : resp.csum = IntToHexString(ntohs(icmp->icmp6_cksum));
505 0 : PktToHexString((uint8_t *)icmp->icmp6_data8, len - 4, resp.rest);
506 0 : }
507 :
508 0 : void ServicesSandesh::FillUdpHdr(udphdr *udp, UdpHdr &resp) {
509 0 : resp.src_port = ntohs(udp->uh_sport);
510 0 : resp.dest_port = ntohs(udp->uh_dport);
511 0 : resp.length = ntohs(udp->uh_ulen);
512 0 : resp.csum = IntToHexString(ntohs(udp->uh_sum));
513 0 : }
514 :
515 : std::string
516 0 : ServicesSandesh::FillOptionString(char *data, int32_t len, std::string msg) {
517 0 : std::string str;
518 0 : if (len > 0)
519 0 : str.assign(data, len);
520 0 : return (msg + str + "; ");
521 0 : }
522 :
523 : std::string
524 0 : ServicesSandesh::FillOptionInteger(uint32_t data, std::string msg) {
525 0 : std::stringstream str;
526 0 : str << msg << data << "; ";
527 0 : return str.str();
528 0 : }
529 :
530 : std::string
531 0 : ServicesSandesh::FillOptionIp(uint32_t data, std::string msg) {
532 0 : Ip4Address addr(data);
533 0 : return msg + addr.to_string() + "; ";
534 : }
535 :
536 : void
537 0 : ServicesSandesh::FillHostRoutes(uint8_t *data, int len,
538 : std::string &resp) {
539 0 : std::stringstream routes;
540 0 : int parsed = 0;
541 0 : uint8_t *ptr = data;
542 0 : while (parsed < len) {
543 0 : uint32_t addr = 0;
544 0 : int plen = *ptr++;
545 0 : parsed++;
546 : int j;
547 0 : for (j = 0; plen && j <= (plen - 1) / 8; ++j) {
548 0 : addr = (addr << 8) | *ptr++;
549 0 : parsed++;
550 : }
551 0 : addr = addr << (4 - j) * 8;
552 0 : Ip4Address prefix(addr);
553 0 : Ip4Address route(get_val(ptr));
554 0 : routes << prefix.to_string() << "/" << plen << " -> "
555 0 : << route.to_string() << ";";
556 0 : ptr += 4;
557 0 : parsed += 4;
558 : }
559 0 : resp += routes.str();
560 0 : }
561 :
562 0 : void ServicesSandesh::FillDhcpv4Options(Dhcpv4Options *opt, std::string &resp,
563 : std::string &other, int32_t len) {
564 0 : while (opt->code != DHCP_OPTION_END && len > 0) {
565 0 : switch (opt->code) {
566 0 : case DHCP_OPTION_PAD:
567 0 : len -= 1;
568 0 : opt = (Dhcpv4Options *)((uint8_t *)opt + 1);
569 0 : continue;
570 :
571 0 : case DHCP_OPTION_MSG_TYPE:
572 0 : if (len >= (2 + opt->len))
573 0 : resp += DhcpMsgType(*(uint8_t *)opt->data) + "; ";
574 0 : break;
575 :
576 0 : case DHCP_OPTION_REQ_IP_ADDRESS: {
577 0 : if (len >= (2 + opt->len)) {
578 0 : Ip4Address addr(get_val(opt->data));
579 0 : resp += "Requested IP : " + addr.to_string() + "; ";
580 : }
581 0 : break;
582 : }
583 :
584 0 : case DHCP_OPTION_HOST_NAME:
585 0 : if (len >= (2 + opt->len))
586 0 : resp += FillOptionString((char *)opt->data, opt->len,
587 0 : "Host Name : ");
588 0 : break;
589 :
590 0 : case DHCP_OPTION_DOMAIN_NAME:
591 0 : if (len >= (2 + opt->len))
592 0 : resp += FillOptionString((char *)opt->data, opt->len,
593 0 : "Domain Name : ");
594 0 : break;
595 :
596 0 : case DHCP_OPTION_MESSAGE:
597 0 : if (len >= (2 + opt->len))
598 0 : resp += FillOptionString((char *)opt->data, opt->len,
599 0 : "Msg : ");
600 0 : break;
601 :
602 0 : case DHCP_OPTION_IP_LEASE_TIME:
603 0 : if (len >= (2 + opt->len))
604 0 : resp += FillOptionInteger(get_val(opt->data), "Lease time : ");
605 0 : break;
606 :
607 0 : case DHCP_OPTION_SUBNET_MASK:
608 0 : if (len >= (2 + opt->len))
609 0 : resp += FillOptionIp(get_val(opt->data), "Subnet mask : ");
610 0 : break;
611 :
612 0 : case DHCP_OPTION_BCAST_ADDRESS:
613 0 : if (len >= (2 + opt->len))
614 0 : resp += FillOptionIp(get_val(opt->data), "Broadcast : ");
615 0 : break;
616 :
617 0 : case DHCP_OPTION_ROUTER:
618 0 : if (len >= (2 + opt->len)) {
619 0 : int16_t optlen = 0;
620 0 : while (optlen < opt->len) {
621 0 : resp += FillOptionIp(get_val(opt->data + optlen),
622 0 : "Gateway : ");
623 0 : optlen += 4;
624 : }
625 : }
626 0 : break;
627 :
628 0 : case DHCP_OPTION_DNS:
629 0 : if (len >= (2 + opt->len))
630 0 : resp += FillOptionIp(get_val(opt->data), "DNS : ");
631 0 : break;
632 :
633 0 : case DHCP_OPTION_TIME_SERVER:
634 0 : if (len >= (2 + opt->len))
635 0 : resp += FillOptionIp(get_val(opt->data), "Time Server : ");
636 0 : break;
637 :
638 0 : case DHCP_OPTION_SERVER_IDENTIFIER:
639 0 : if (len >= (2 + opt->len))
640 0 : resp += FillOptionIp(get_val(opt->data), "Server : ");
641 0 : break;
642 :
643 0 : case DHCP_OPTION_CLASSLESS_ROUTE:
644 0 : if (len >= (2 + opt->len)) {
645 0 : resp += "Host Routes : ";
646 0 : FillHostRoutes(opt->data, opt->len, resp);
647 : }
648 0 : break;
649 :
650 0 : default:
651 0 : PktToHexString((uint8_t *)opt, opt->len + 2, other);
652 0 : break;
653 0 : }
654 0 : len -= (2 + opt->len);
655 0 : opt = (Dhcpv4Options *)((uint8_t *)opt + 2 + opt->len);
656 : }
657 0 : }
658 :
659 0 : void ServicesSandesh::FillDhcpv4Hdr(dhcphdr *dhcp, Dhcpv4Hdr &resp,
660 : int32_t len) {
661 0 : resp.op = (dhcp->op == 1) ? "request" : "reply";
662 0 : resp.htype = (dhcp->htype == 1) ? "ethernet" : IntToString(dhcp->htype);
663 0 : resp.hlen = dhcp->hlen;
664 0 : resp.hops = dhcp->hops;
665 0 : resp.xid = IntToHexString(dhcp->xid);
666 0 : resp.secs = ntohs(dhcp->secs);
667 : resp.flags =
668 0 : (ntohs(dhcp->flags) & DHCP_BCAST_FLAG) ? "broadcast" : "unicast";
669 0 : Ip4Address ciaddr(ntohl(dhcp->ciaddr));
670 0 : Ip4Address yiaddr(ntohl(dhcp->yiaddr));
671 0 : Ip4Address siaddr(ntohl(dhcp->siaddr));
672 0 : Ip4Address giaddr(ntohl(dhcp->giaddr));
673 0 : resp.ciaddr = ciaddr.to_string();
674 0 : resp.yiaddr = yiaddr.to_string();
675 0 : resp.siaddr = siaddr.to_string();
676 0 : resp.giaddr = giaddr.to_string();
677 0 : PktToHexString(dhcp->chaddr, DHCP_CHADDR_LEN, resp.chaddr);
678 0 : PktToHexString(dhcp->sname, DHCP_NAME_LEN, resp.sname);
679 0 : PktToHexString(dhcp->file, DHCP_FILE_LEN, resp.file);
680 0 : PktToHexString(dhcp->options, 4, resp.cookie);
681 0 : len -= (DHCP_FIXED_LEN + 4);
682 0 : FillDhcpv4Options((Dhcpv4Options *)(dhcp->options + 4),
683 0 : resp.dhcp_options, resp.other_options, len);
684 0 : }
685 :
686 0 : void ServicesSandesh::FillDhcpv6Hdr(Dhcpv6Hdr *dhcp, Dhcpv6Header &resp,
687 : int32_t len) {
688 0 : resp.type = Dhcpv6MsgType(dhcp->type);
689 0 : PktToHexString(dhcp->xid, 3, resp.xid);
690 0 : PktToHexString((uint8_t *)dhcp + DHCPV6_FIXED_LEN, len - 4, resp.options);
691 0 : }
692 :
693 0 : void ServicesSandesh::FillDnsHdr(dnshdr *dns, DnsHdr &resp, int32_t dnslen) {
694 0 : if (dnslen < (int32_t)sizeof(dnshdr))
695 0 : return;
696 :
697 0 : resp.xid = ntohs(dns->xid);
698 0 : if (dns->flags.rd)
699 0 : resp.flags += "recursion desired; ";
700 0 : if (dns->flags.trunc)
701 0 : resp.flags += "truncated; ";
702 0 : if (dns->flags.auth)
703 0 : resp.flags += "authoritative answer; ";
704 0 : resp.flags += (!dns->flags.op) ? "query; " :
705 0 : ((dns->flags.op == DNS_OPCODE_UPDATE)? "update; " :
706 0 : "other op; ");
707 0 : if (dns->flags.req) {
708 0 : resp.flags += "response; ";
709 0 : if (dns->flags.ret)
710 0 : resp.flags += "failure response : " +
711 0 : IntToString(dns->flags.ret) + "; ";
712 : else
713 0 : resp.flags += "success response; ";
714 : } else {
715 0 : resp.flags += "request; ";
716 : }
717 0 : if (dns->flags.cd)
718 0 : resp.flags += "checking disabled; ";
719 0 : if (dns->flags.ad)
720 0 : resp.flags += "answer authenticated; ";
721 0 : if (dns->flags.ra)
722 0 : resp.flags += "recursion available; ";
723 0 : resp.ques = ntohs(dns->ques_rrcount);
724 0 : resp.ans = ntohs(dns->ans_rrcount);
725 0 : resp.auth = ntohs(dns->auth_rrcount);
726 0 : resp.add = ntohs(dns->add_rrcount);
727 0 : dnslen -= sizeof(dnshdr);
728 0 : ServicesSandesh::PktToHexString((uint8_t *)(dns + 1), dnslen, resp.rest);
729 : }
730 :
731 0 : void ServicesSandesh::ArpPktTrace(PktTrace::Pkt &pkt, ArpPktSandesh *resp) {
732 0 : ArpPkt data;
733 0 : FillPktData(pkt, data.info);
734 0 : uint16_t hdr_len = FillVrouterHdr(pkt, data.agent_hdr);
735 0 : uint8_t *ptr = pkt.pkt + hdr_len;
736 0 : ptr += FillMacHdr((struct ether_header *)ptr, data.mac_hdr);
737 0 : FillArpHdr((ether_arp *)ptr, data.arp_hdr);
738 : std::vector<ArpPkt> &list =
739 0 : const_cast<std::vector<ArpPkt>&>(resp->get_pkt_list());
740 0 : list.push_back(data);
741 0 : }
742 :
743 0 : void ServicesSandesh::DhcpPktTrace(PktTrace::Pkt &pkt, DhcpPktSandesh *resp) {
744 0 : DhcpPkt data;
745 0 : FillPktData(pkt, data.info);
746 0 : uint16_t hdr_len = FillVrouterHdr(pkt, data.agent_hdr);
747 0 : uint8_t *ptr = pkt.pkt + hdr_len;
748 0 : ptr += FillMacHdr((struct ether_header *)ptr, data.mac_hdr);
749 0 : FillIpv4Hdr((struct ip *)ptr, data.ip_hdr);
750 0 : ptr += (data.ip_hdr.hdrlen * 4);
751 0 : FillUdpHdr((udphdr *)ptr, data.udp_hdr);
752 0 : ptr += sizeof(udphdr);
753 0 : PktHandler *pkt_handler = Agent::GetInstance()->pkt()->pkt_handler();
754 0 : std::size_t trace_size = pkt_handler->PktTraceSize(PktHandler::DHCP);
755 0 : int32_t remaining = std::min(pkt.len, trace_size) -
756 : (sizeof(struct ether_header) +
757 0 : data.ip_hdr.hdrlen * 4 + sizeof(udphdr));
758 0 : FillDhcpv4Hdr((dhcphdr *)ptr, data.dhcp_hdr, remaining);
759 : std::vector<DhcpPkt> &list =
760 0 : const_cast<std::vector<DhcpPkt>&>(resp->get_pkt_list());
761 0 : list.push_back(data);
762 0 : }
763 :
764 0 : void ServicesSandesh::Dhcpv6PktTrace(PktTrace::Pkt &pkt, Dhcpv6PktSandesh *resp) {
765 0 : Dhcpv6Pkt data;
766 0 : FillPktData(pkt, data.info);
767 0 : uint16_t hdr_len = FillVrouterHdr(pkt, data.agent_hdr);
768 0 : uint8_t *ptr = pkt.pkt + hdr_len;
769 0 : ptr += FillMacHdr((struct ether_header *)ptr, data.mac_hdr);
770 0 : FillIpv6Hdr((ip6_hdr *)ptr, data.ip_hdr);
771 0 : ptr += sizeof(ip6_hdr);
772 0 : FillUdpHdr((udphdr *)ptr, data.udp_hdr);
773 0 : ptr += sizeof(udphdr);
774 0 : PktHandler *pkt_handler = Agent::GetInstance()->pkt()->pkt_handler();
775 0 : std::size_t trace_size = pkt_handler->PktTraceSize(PktHandler::DHCPV6);
776 0 : int32_t remaining = std::min(pkt.len, trace_size) -
777 0 : (sizeof(struct ether_header) + sizeof(ip6_hdr) + sizeof(udphdr));
778 0 : FillDhcpv6Hdr((Dhcpv6Hdr *)ptr, data.dhcp_hdr, remaining);
779 : std::vector<Dhcpv6Pkt> &list =
780 0 : const_cast<std::vector<Dhcpv6Pkt>&>(resp->get_pkt_list());
781 0 : list.push_back(data);
782 0 : }
783 :
784 0 : void ServicesSandesh::DnsPktTrace(PktTrace::Pkt &pkt, DnsPktSandesh *resp) {
785 0 : DnsPkt data;
786 0 : FillPktData(pkt, data.info);
787 0 : uint16_t hdr_len = FillVrouterHdr(pkt, data.agent_hdr);
788 0 : uint8_t *ptr = pkt.pkt + hdr_len;
789 0 : ptr += FillMacHdr((struct ether_header *)ptr, data.mac_hdr);
790 0 : FillIpv4Hdr((struct ip *)ptr, data.ip_hdr);
791 0 : ptr += (data.ip_hdr.hdrlen * 4);
792 0 : FillUdpHdr((udphdr *)ptr, data.udp_hdr);
793 0 : ptr += sizeof(udphdr);
794 0 : PktHandler *pkt_handler = Agent::GetInstance()->pkt()->pkt_handler();
795 0 : std::size_t trace_size = pkt_handler->PktTraceSize(PktHandler::DNS);
796 0 : int32_t remaining = std::min(pkt.len, trace_size) -
797 : (sizeof(struct ether_header) +
798 0 : data.ip_hdr.hdrlen * 4 + sizeof(udphdr));
799 0 : FillDnsHdr((dnshdr *)ptr, data.dns_hdr, remaining);
800 : std::vector<DnsPkt> &list =
801 0 : const_cast<std::vector<DnsPkt>&>(resp->get_pkt_list());
802 0 : list.push_back(data);
803 0 : }
804 :
805 0 : void ServicesSandesh::IcmpPktTrace(PktTrace::Pkt &pkt, IcmpPktSandesh *resp) {
806 0 : IcmpPkt data;
807 0 : FillPktData(pkt, data.info);
808 0 : uint16_t hdr_len = FillVrouterHdr(pkt, data.agent_hdr);
809 0 : uint8_t *ptr = pkt.pkt + hdr_len;
810 0 : ptr += FillMacHdr((struct ether_header *)ptr, data.mac_hdr);
811 0 : FillIpv4Hdr((struct ip *)ptr, data.ip_hdr);
812 0 : ptr += (data.ip_hdr.hdrlen * 4);
813 0 : FillIcmpv4Hdr((struct icmp *)ptr, data.icmp_hdr);
814 : std::vector<IcmpPkt> &list =
815 0 : const_cast<std::vector<IcmpPkt>&>(resp->get_pkt_list());
816 0 : list.push_back(data);
817 0 : }
818 :
819 0 : void ServicesSandesh::Icmpv6PktTrace(PktTrace::Pkt &pkt, Icmpv6PktSandesh *resp) {
820 0 : Icmpv6Pkt data;
821 0 : FillPktData(pkt, data.info);
822 0 : uint16_t hdr_len = FillVrouterHdr(pkt, data.agent_hdr);
823 0 : uint8_t *ptr = pkt.pkt + hdr_len;
824 0 : ptr += FillMacHdr((struct ether_header *)ptr, data.mac_hdr);
825 0 : FillIpv6Hdr((ip6_hdr *)ptr, data.ip_hdr);
826 0 : ptr += sizeof(ip6_hdr);
827 0 : PktHandler *pkt_handler = Agent::GetInstance()->pkt()->pkt_handler();
828 0 : std::size_t trace_size = pkt_handler->PktTraceSize(PktHandler::ICMPV6);
829 0 : int32_t remaining = std::min(pkt.len, trace_size) -
830 0 : (sizeof(struct ether_header) + sizeof(ip6_hdr));
831 0 : FillIcmpv6Hdr((icmp6_hdr *)ptr, data.icmp_hdr, remaining);
832 : std::vector<Icmpv6Pkt> &list =
833 0 : const_cast<std::vector<Icmpv6Pkt>&>(resp->get_pkt_list());
834 0 : list.push_back(data);
835 0 : }
836 :
837 0 : void ServicesSandesh::OtherPktTrace(PktTrace::Pkt &pkt, PktSandesh *resp) {
838 0 : PktDump data;
839 0 : FillPktData(pkt, data.info);
840 0 : uint16_t hdr_len = FillVrouterHdr(pkt, data.agent_hdr);
841 0 : uint8_t *ptr = pkt.pkt + hdr_len;
842 0 : ptr += FillMacHdr((struct ether_header *)ptr, data.mac_hdr);
843 0 : PktHandler *pkt_handler = Agent::GetInstance()->pkt()->pkt_handler();
844 0 : std::size_t trace_size = pkt_handler->PktTraceSize(PktHandler::FLOW);
845 0 : int32_t remaining = std::min(pkt.len, trace_size) - sizeof(struct ether_header);
846 0 : PktToHexString(ptr, remaining, data.pkt);
847 : std::vector<PktDump> &list =
848 0 : const_cast<std::vector<PktDump>&>(resp->get_pkt_list());
849 0 : list.push_back(data);
850 0 : }
851 :
852 0 : void ServicesSandesh::HandleRequest(PktHandler::PktModuleName mod,
853 : std::string ctxt, bool more = false) {
854 0 : SandeshResponse *resp = NULL;
855 0 : boost::function<void(PktTrace::Pkt &)> cb;
856 : boost::array<std::string, PktHandler::MAX_MODULES> names =
857 : { { "Invalid", "Flow", "Arp", "Dhcp", "Dhcpv6", "Dns",
858 : "Icmp", "Icmpv6", "Diagnostics", "IcmpError", "RxPacket",
859 0 : "MacLearning" } };
860 :
861 0 : switch (mod) {
862 0 : case PktHandler::ARP:
863 0 : resp = new ArpPktSandesh();
864 0 : ArpStatsSandesh(ctxt, true);
865 0 : static_cast<ArpPktSandesh *>(resp)->set_type(names.at(mod));
866 : cb = boost::bind(&ServicesSandesh::ArpPktTrace, this, _1,
867 0 : static_cast<ArpPktSandesh *>(resp));
868 0 : break;
869 :
870 0 : case PktHandler::BFD:
871 0 : BfdStatsSandesh(ctxt, false);
872 0 : return;
873 :
874 0 : case PktHandler::DHCP:
875 0 : resp = new DhcpPktSandesh();
876 0 : DhcpStatsSandesh(ctxt, true);
877 0 : static_cast<DhcpPktSandesh *>(resp)->set_type(names.at(mod));
878 : cb = boost::bind(&ServicesSandesh::DhcpPktTrace, this, _1,
879 0 : static_cast<DhcpPktSandesh *>(resp));
880 0 : break;
881 :
882 0 : case PktHandler::DHCPV6:
883 0 : resp = new Dhcpv6PktSandesh();
884 0 : Dhcpv6StatsSandesh(ctxt, true);
885 0 : static_cast<Dhcpv6PktSandesh *>(resp)->set_type(names.at(mod));
886 : cb = boost::bind(&ServicesSandesh::Dhcpv6PktTrace, this, _1,
887 0 : static_cast<Dhcpv6PktSandesh *>(resp));
888 0 : break;
889 :
890 0 : case PktHandler::DNS:
891 0 : resp = new DnsPktSandesh();
892 0 : DnsStatsSandesh(ctxt, true);
893 0 : static_cast<DnsPktSandesh *>(resp)->set_type(names.at(mod));
894 : cb = boost::bind(&ServicesSandesh::DnsPktTrace, this, _1,
895 0 : static_cast<DnsPktSandesh *>(resp));
896 0 : break;
897 :
898 0 : case PktHandler::ICMP:
899 0 : resp = new IcmpPktSandesh();
900 0 : IcmpStatsSandesh(ctxt, true);
901 0 : static_cast<IcmpPktSandesh *>(resp)->set_type(names.at(mod));
902 : cb = boost::bind(&ServicesSandesh::IcmpPktTrace, this, _1,
903 0 : static_cast<IcmpPktSandesh *>(resp));
904 0 : break;
905 :
906 0 : case PktHandler::ICMPV6:
907 0 : resp = new Icmpv6PktSandesh();
908 0 : Icmpv6StatsSandesh(ctxt, true);
909 0 : static_cast<Icmpv6PktSandesh *>(resp)->set_type(names.at(mod));
910 : cb = boost::bind(&ServicesSandesh::Icmpv6PktTrace, this, _1,
911 0 : static_cast<Icmpv6PktSandesh *>(resp));
912 0 : break;
913 :
914 0 : case PktHandler::IGMP:
915 0 : IgmpStatsSandesh(ctxt, false);
916 0 : return;
917 :
918 0 : case PktHandler::FLOW:
919 : case PktHandler::DIAG:
920 : case PktHandler::INVALID:
921 : case PktHandler::MAC_LEARNING:
922 0 : resp = new PktSandesh();
923 0 : static_cast<PktSandesh *>(resp)->set_type(names.at(mod));
924 : cb = boost::bind(&ServicesSandesh::OtherPktTrace, this, _1,
925 0 : static_cast<PktSandesh *>(resp));
926 0 : break;
927 :
928 0 : default:
929 0 : break;
930 : }
931 :
932 0 : Agent::GetInstance()->pkt()->pkt_handler()->PktTraceIterate(mod, cb);
933 0 : resp->set_context(ctxt);
934 0 : resp->set_more(more);
935 0 : resp->Response();
936 0 : }
937 :
938 0 : void ServicesSandesh::MetadataHandleRequest(std::string ctxt, bool more = false) {
939 0 : MetadataResponse *resp = new MetadataResponse();
940 0 : resp->set_metadata_server_port(
941 0 : Agent::GetInstance()->metadata_server_port());
942 : const MetadataProxy::MetadataStats &stats =
943 0 : Agent::GetInstance()->services()->metadataproxy()->metadatastats();
944 0 : resp->set_metadata_requests(stats.requests);
945 0 : resp->set_metadata_responses(stats.responses);
946 0 : resp->set_metadata_proxy_sessions(stats.proxy_sessions);
947 0 : resp->set_metadata_internal_errors(stats.internal_errors);
948 0 : resp->set_context(ctxt);
949 0 : resp->set_more(more);
950 0 : resp->Response();
951 0 : }
952 :
953 : ///////////////////////////////////////////////////////////////////////////////
954 :
955 0 : void DhcpInfo::HandleRequest() const {
956 0 : ServicesSandesh ssandesh;
957 0 : ssandesh.HandleRequest(PktHandler::DHCP, context());
958 0 : }
959 :
960 0 : void Dhcpv6Info::HandleRequest() const {
961 0 : ServicesSandesh ssandesh;
962 0 : ssandesh.HandleRequest(PktHandler::DHCPV6, context());
963 0 : }
964 :
965 0 : void ArpInfo::HandleRequest() const {
966 0 : ServicesSandesh ssandesh;
967 0 : ssandesh.HandleRequest(PktHandler::ARP, context());
968 0 : }
969 :
970 0 : void BfdInfo::HandleRequest() const {
971 0 : ServicesSandesh ssandesh;
972 0 : ssandesh.HandleRequest(PktHandler::BFD, context());
973 0 : }
974 :
975 0 : void DnsInfo::HandleRequest() const {
976 0 : ServicesSandesh ssandesh;
977 0 : ssandesh.HandleRequest(PktHandler::DNS, context());
978 0 : }
979 :
980 0 : void IcmpInfo::HandleRequest() const {
981 0 : ServicesSandesh ssandesh;
982 0 : ssandesh.HandleRequest(PktHandler::ICMP, context());
983 0 : }
984 :
985 0 : void Icmpv6Info::HandleRequest() const {
986 0 : ServicesSandesh ssandesh;
987 0 : ssandesh.HandleRequest(PktHandler::ICMPV6, context());
988 0 : }
989 :
990 0 : void IgmpStatsReq::HandleRequest() const {
991 0 : ServicesSandesh ssandesh;
992 0 : ssandesh.HandleRequest(PktHandler::IGMP, context());
993 0 : }
994 :
995 0 : void GmpStatsReq::HandleRequest() const {
996 0 : GmpStatsResponse *gmp = new GmpStatsResponse();
997 0 : GmpProto *gmp_proto_ = Agent::GetInstance()->GetIgmpProto()->GetGmpProto();
998 0 : const GmpProto::GmpStats &stats = gmp_proto_->GetStats();
999 0 : gmp->set_gmp_g_add_count(stats.gmp_g_add_count_);
1000 0 : gmp->set_gmp_g_del_count(stats.gmp_g_del_count_);
1001 0 : gmp->set_gmp_sg_add_count(stats.gmp_sg_add_count_);
1002 0 : gmp->set_gmp_sg_del_count(stats.gmp_sg_del_count_);
1003 0 : gmp->set_context(context());
1004 0 : gmp->set_more(false);
1005 0 : gmp->Response();
1006 0 : }
1007 :
1008 0 : static void SandeshError(const std::string msg, const std::string &context) {
1009 0 : IgmpErrorResp *resp = new IgmpErrorResp();
1010 0 : resp->set_resp(msg);
1011 0 : resp->set_context(context);
1012 0 : resp->set_more(false);
1013 0 : resp->Response();
1014 0 : }
1015 :
1016 0 : void InterfaceIgmpStatsReq::HandleRequest() const {
1017 0 : std::string vn_uuid = get_vn_uuid();
1018 0 : std::string gw = get_ipam_gateway();
1019 0 : InterfaceIgmpStatsResponse *igmp = new InterfaceIgmpStatsResponse();
1020 0 : IgmpStats rx_badpacket_stats;
1021 0 : IgmpStats rx_okpacket_stats;
1022 0 : IgmpInfo::IgmpItfStats stats;
1023 :
1024 0 : if (vn_uuid.empty() || gw.empty()) {
1025 0 : SandeshError("Empty vn_uuid or gateway !!", context());
1026 0 : return;
1027 : }
1028 :
1029 : VnEntry *vn =
1030 0 : Agent::GetInstance()->vn_table()->Find(StringToUuid(vn_uuid));
1031 0 : if (!vn ) {
1032 0 : SandeshError("Invalid UUID !!", context());
1033 0 : return;
1034 : }
1035 :
1036 0 : boost::system::error_code ec;
1037 0 : IpAddress gateway = IpAddress(Ip4Address::from_string(gw, ec));
1038 0 : if (Agent::GetInstance()->GetIgmpProto()->GetItfStats(vn, gateway,
1039 0 : stats) == false ) {
1040 0 : SandeshError("Stats not found !!", context());
1041 0 : return;
1042 : }
1043 :
1044 0 : igmp->set_rx_unknown(stats.rx_unknown);
1045 0 : igmp->set_tx_packet(stats.tx_packet);
1046 0 : igmp->set_tx_drop_packet(stats.tx_drop_packet);
1047 :
1048 0 : rx_badpacket_stats.undefined =
1049 0 : stats.rx_badpacket[IGMP_UNDEFINED - 1];
1050 0 : rx_badpacket_stats.igmp_membership_query =
1051 0 : stats.rx_badpacket[IGMP_MEMBERSHIP_QUERY - 1];
1052 0 : rx_badpacket_stats.igmp_v1_membership_report =
1053 0 : stats.rx_badpacket[IGMP_V1_MEMBERSHIP_REPORT - 1];
1054 0 : rx_badpacket_stats.igmp_proto_dvmrp =
1055 0 : stats.rx_badpacket[IGMP_PROTO_DVMRP - 1];
1056 0 : rx_badpacket_stats.igmp_proto_pim =
1057 0 : stats.rx_badpacket[IGMP_PROTO_PIM - 1];
1058 0 : rx_badpacket_stats.igmp_cisco_trace =
1059 0 : stats.rx_badpacket[IGMP_CISCO_TRACE - 1];
1060 0 : rx_badpacket_stats.igmp_v2_membership_report =
1061 0 : stats.rx_badpacket[IGMP_V2_MEMBERSHIP_REPORT - 1];
1062 0 : rx_badpacket_stats.igmp_group_leave =
1063 0 : stats.rx_badpacket[IGMP_GROUP_LEAVE - 1];
1064 0 : rx_badpacket_stats.igmp_mtrace_response =
1065 0 : stats.rx_badpacket[IGMP_MTRACE_RESPONSE - 1];
1066 0 : rx_badpacket_stats.igmp_mtrace_request =
1067 0 : stats.rx_badpacket[IGMP_MTRACE_REQUEST - 1];
1068 0 : rx_badpacket_stats.igmp_dwr =
1069 0 : stats.rx_badpacket[IGMP_DWR - 1];
1070 0 : rx_badpacket_stats.igmp_v3_membership_report =
1071 0 : stats.rx_badpacket[IGMP_V3_MEMBERSHIP_REPORT - 1];
1072 0 : igmp->set_rx_badpacket_stats(rx_badpacket_stats);
1073 :
1074 0 : rx_okpacket_stats.undefined =
1075 0 : stats.rx_okpacket[IGMP_UNDEFINED - 1];
1076 0 : rx_okpacket_stats.igmp_membership_query =
1077 0 : stats.rx_okpacket[IGMP_MEMBERSHIP_QUERY - 1];
1078 0 : rx_okpacket_stats.igmp_v1_membership_report =
1079 0 : stats.rx_okpacket[IGMP_V1_MEMBERSHIP_REPORT - 1];
1080 0 : rx_okpacket_stats.igmp_proto_dvmrp =
1081 0 : stats.rx_okpacket[IGMP_PROTO_DVMRP - 1];
1082 0 : rx_okpacket_stats.igmp_proto_pim =
1083 0 : stats.rx_okpacket[IGMP_PROTO_PIM - 1];
1084 0 : rx_okpacket_stats.igmp_cisco_trace =
1085 0 : stats.rx_okpacket[IGMP_CISCO_TRACE - 1];
1086 0 : rx_okpacket_stats.igmp_v2_membership_report =
1087 0 : stats.rx_okpacket[IGMP_V2_MEMBERSHIP_REPORT - 1];
1088 0 : rx_okpacket_stats.igmp_group_leave =
1089 0 : stats.rx_okpacket[IGMP_GROUP_LEAVE - 1];
1090 0 : rx_okpacket_stats.igmp_mtrace_response =
1091 0 : stats.rx_okpacket[IGMP_MTRACE_RESPONSE - 1];
1092 0 : rx_okpacket_stats.igmp_mtrace_request =
1093 0 : stats.rx_okpacket[IGMP_MTRACE_REQUEST - 1];
1094 0 : rx_okpacket_stats.igmp_dwr =
1095 0 : stats.rx_okpacket[IGMP_DWR - 1];
1096 0 : rx_okpacket_stats.igmp_v3_membership_report =
1097 0 : stats.rx_okpacket[IGMP_V3_MEMBERSHIP_REPORT - 1];
1098 0 : igmp->set_rx_okpacket_stats(rx_okpacket_stats);
1099 :
1100 0 : igmp->set_context(context());
1101 0 : igmp->Response();
1102 0 : }
1103 :
1104 0 : void MetadataInfo::HandleRequest() const {
1105 0 : ServicesSandesh ssandesh;
1106 0 : ssandesh.MetadataHandleRequest(context());
1107 0 : }
1108 :
1109 0 : void MacLearningInfo::HandleRequest() const {
1110 0 : ServicesSandesh ssandesh;
1111 0 : ssandesh.HandleRequest(PktHandler::MAC_LEARNING, context());
1112 0 : }
1113 :
1114 0 : void ShowAllInfo::HandleRequest() const {
1115 0 : ServicesSandesh ssandesh;
1116 0 : ssandesh.PktStatsSandesh(context(), true);
1117 0 : ssandesh.HandleRequest(PktHandler::DHCP, context(), true);
1118 0 : ssandesh.HandleRequest(PktHandler::ARP, context(), true);
1119 0 : ssandesh.HandleRequest(PktHandler::DNS, context(), true);
1120 0 : ssandesh.HandleRequest(PktHandler::ICMP, context(), true);
1121 0 : ssandesh.HandleRequest(PktHandler::FLOW, context(), true);
1122 0 : ssandesh.HandleRequest(PktHandler::DIAG, context(), true);
1123 0 : ssandesh.HandleRequest(PktHandler::INVALID, context(), true);
1124 0 : ssandesh.HandleRequest(PktHandler::MAC_LEARNING, context(), true);
1125 0 : ssandesh.MetadataHandleRequest(context(), false);
1126 0 : }
1127 :
1128 0 : void ClearAllInfo::HandleRequest() const {
1129 0 : Agent *agent = Agent::GetInstance();
1130 0 : PktHandler *pkt_handler = agent->pkt()->pkt_handler();
1131 0 : pkt_handler->PktTraceClear(PktHandler::DHCP);
1132 0 : pkt_handler->PktTraceClear(PktHandler::DHCPV6);
1133 0 : pkt_handler->PktTraceClear(PktHandler::ARP);
1134 0 : pkt_handler->PktTraceClear(PktHandler::DNS);
1135 0 : pkt_handler->PktTraceClear(PktHandler::ICMP);
1136 0 : pkt_handler->PktTraceClear(PktHandler::ICMPV6);
1137 0 : pkt_handler->PktTraceClear(PktHandler::FLOW);
1138 0 : pkt_handler->PktTraceClear(PktHandler::DIAG);
1139 0 : pkt_handler->PktTraceClear(PktHandler::INVALID);
1140 0 : pkt_handler->PktTraceClear(PktHandler::MAC_LEARNING);
1141 0 : pkt_handler->ClearStats();
1142 0 : agent->GetDhcpProto()->ClearStats();
1143 0 : agent->dhcpv6_proto()->ClearStats();
1144 0 : agent->GetArpProto()->ClearStats();
1145 0 : agent->GetDnsProto()->ClearStats();
1146 0 : agent->GetIcmpProto()->ClearStats();
1147 0 : agent->icmpv6_proto()->ClearStats();
1148 0 : agent->services()->metadataproxy()->ClearStats();
1149 :
1150 0 : PktErrorResp *resp = new PktErrorResp();
1151 0 : resp->set_context(context());
1152 0 : resp->Response();
1153 0 : }
1154 :
1155 0 : void PktTraceInfo::HandleRequest() const {
1156 0 : uint32_t buffers = get_num_buffers();
1157 0 : uint32_t flow_buffers = get_flow_num_buffers();
1158 0 : PktTraceInfoResponse *resp = new PktTraceInfoResponse();
1159 0 : PktHandler *handler = Agent::GetInstance()->pkt()->pkt_handler();
1160 0 : if (buffers > PktTrace::kPktMaxNumBuffers ||
1161 : flow_buffers > PktTrace::kPktMaxNumBuffers) {
1162 0 : resp->set_resp("Invalid Input !!");
1163 0 : buffers = handler->PktTraceBuffers(PktHandler::INVALID);
1164 0 : flow_buffers = handler->PktTraceBuffers(PktHandler::FLOW);
1165 : } else {
1166 0 : handler->PktTraceBuffers(PktHandler::FLOW, flow_buffers);
1167 0 : for (uint32_t i = 0; i < PktHandler::MAX_MODULES; ++i) {
1168 0 : if (i == PktHandler::FLOW)
1169 0 : continue;
1170 0 : handler->PktTraceBuffers((PktHandler::PktModuleName)i, buffers);
1171 : }
1172 : }
1173 0 : resp->set_num_buffers(buffers);
1174 0 : resp->set_flow_num_buffers(flow_buffers);
1175 0 : resp->set_context(context());
1176 0 : resp->Response();
1177 0 : }
1178 :
1179 : ///////////////////////////////////////////////////////////////////////////////
1180 :
1181 0 : void ShowDnsEntries::HandleRequest() const {
1182 0 : AgentDnsEntries *resp = new AgentDnsEntries();
1183 0 : std::vector<VmDnsSandesh> dns_list;
1184 : const DnsProto::DnsUpdateSet &dns_update_set =
1185 0 : Agent::GetInstance()->GetDnsProto()->update_set();
1186 0 : for (DnsProto::DnsUpdateSet::const_iterator it = dns_update_set.begin();
1187 0 : it != dns_update_set.end(); ++it) {
1188 0 : VmDnsSandesh vmdata;
1189 0 : vmdata.vm = (*it)->itf->name();
1190 0 : vmdata.is_floating = ((*it)->floatingIp ? "yes" : "no");
1191 0 : if ((*it)->xmpp_data) {
1192 0 : vmdata.virtual_dns = (*it)->xmpp_data->virtual_dns;
1193 0 : vmdata.zone = (*it)->xmpp_data->zone;
1194 0 : for (DnsItems::iterator item = (*it)->xmpp_data->items.begin();
1195 0 : item != (*it)->xmpp_data->items.end(); ++item) {
1196 0 : VmDnsRecord record;
1197 0 : record.name = (*item).name;
1198 0 : record.type = BindUtil::DnsType((*item).type);
1199 0 : record.data = (*item).data;
1200 0 : record.ttl = (*item).ttl;
1201 0 : record.eclass = BindUtil::DnsClass((*item).eclass);
1202 0 : vmdata.records.push_back(record);
1203 0 : }
1204 : }
1205 0 : dns_list.push_back(vmdata);
1206 0 : }
1207 0 : resp->set_dns_list(dns_list);
1208 0 : resp->set_context(context());
1209 0 : resp->Response();
1210 0 : }
1211 :
1212 0 : void VmVdnsListReq::HandleRequest() const {
1213 0 : VmVdnsListResponse *resp = new VmVdnsListResponse();
1214 0 : resp->set_context(context());
1215 :
1216 0 : const DnsProto::VmDataMap& vm_list = Agent::GetInstance()->GetDnsProto()->all_vms();
1217 : std::vector<VmVdnsListEntry> &list =
1218 0 : const_cast<std::vector<VmVdnsListEntry>&>(resp->get_rlist());
1219 0 : DnsProto::VmDataMap::const_iterator it = vm_list.begin();
1220 0 : while (it != vm_list.end()) {
1221 0 : const VmInterface *itf = it->first;
1222 0 : VmVdnsListEntry entry;
1223 0 : entry.set_name(itf->name());
1224 0 : entry.set_vm_interface_index(itf->id());
1225 0 : list.push_back(entry);
1226 0 : ++it;
1227 0 : }
1228 0 : resp->Response();
1229 0 : }
1230 :
1231 0 : void VmVdnsDataReq::HandleRequest() const {
1232 0 : VmVdnsDataResponse *resp = new VmVdnsDataResponse();
1233 0 : resp->set_context(context());
1234 :
1235 0 : Agent *agent = Agent::GetInstance();
1236 : const VmInterface *vmi = static_cast<const VmInterface *>
1237 0 : (agent->interface_table()->FindInterface(get_vm_interface_index()));
1238 0 : if (vmi == NULL) {
1239 0 : resp->Response();
1240 0 : return;
1241 : }
1242 0 : const DnsProto::VmDataMap& all_vms = agent->GetDnsProto()->all_vms();
1243 0 : DnsProto::VmDataMap::const_iterator it = all_vms.find(vmi);
1244 0 : if (it == all_vms.end()) {
1245 0 : resp->Response();
1246 0 : return;
1247 : }
1248 0 : const DnsProto::IpVdnsMap &ip_list = it->second;
1249 0 : DnsProto::IpVdnsMap::const_iterator ip_it = ip_list.begin();
1250 : std::vector<VmVdnsDataEntry> &list =
1251 0 : const_cast<std::vector<VmVdnsDataEntry>&>(resp->get_rlist());
1252 0 : while (ip_it != ip_list.end()) {
1253 0 : VmVdnsDataEntry entry;
1254 0 : Ip4Address ip4(ip_it->first);
1255 0 : entry.set_ip(ip4.to_string());
1256 0 : entry.set_vdns_name(ip_it->second);
1257 0 : list.push_back(entry);
1258 0 : ++ip_it;
1259 0 : }
1260 0 : resp->Response();
1261 : }
1262 :
1263 0 : void FipVdnsDataReq::HandleRequest() const {
1264 0 : FipVdnsDataResponse *resp = new FipVdnsDataResponse();
1265 0 : resp->set_context(context());
1266 : const DnsProto::DnsFipSet& fip_list = Agent::GetInstance()->GetDnsProto()
1267 0 : ->fip_list();
1268 : std::vector<FipVdnsEntry> &list =
1269 0 : const_cast<std::vector<FipVdnsEntry>&>(resp->get_rlist());
1270 0 : DnsProto::DnsFipSet::const_iterator it = fip_list.begin();
1271 0 : while (it != fip_list.end()) {
1272 0 : FipVdnsEntry entry;
1273 0 : const DnsProto::DnsFipEntry *fip = (*it).get();
1274 0 : IpAddress ip(fip->floating_ip_);
1275 0 : entry.set_vn(fip->vn_->GetName());
1276 0 : entry.set_ip(ip.to_string());
1277 0 : entry.set_vm_interface(fip->interface_->name());
1278 0 : entry.set_vdns_name(fip->vdns_name_);
1279 0 : list.push_back(entry);
1280 0 : ++it;
1281 0 : }
1282 :
1283 0 : resp->Response();
1284 0 : }
1285 :
1286 : ///////////////////////////////////////////////////////////////////////////////
1287 :
1288 0 : void ShowArpCache::HandleRequest() const {
1289 0 : ArpCacheResp *resp = new ArpCacheResp();
1290 0 : resp->set_context(context());
1291 0 : ArpSandesh *arp_sandesh = new ArpSandesh(resp);
1292 : const ArpProto::ArpCache &cache =
1293 0 : (Agent::GetInstance()->GetArpProto()->arp_cache());
1294 0 : for (ArpProto::ArpCache::const_iterator it = cache.begin();
1295 0 : it != cache.end(); it++) {
1296 0 : if (!arp_sandesh->SetArpEntry(it->first, it->second))
1297 0 : break;
1298 : }
1299 0 : arp_sandesh->Response();
1300 0 : delete arp_sandesh;
1301 0 : }
1302 :
1303 0 : void ShowGratuitousArpCache::HandleRequest() const {
1304 0 : ArpCacheResp *resp = new ArpCacheResp();
1305 0 : resp->set_context(context());
1306 0 : ArpSandesh *arp_sandesh = new ArpSandesh(resp);
1307 : const ArpProto::GratuitousArpCache &cache =
1308 0 : (Agent::GetInstance()->GetArpProto()->gratuitous_arp_cache());
1309 0 : for (ArpProto::GratuitousArpCache::const_iterator it = cache.begin();
1310 0 : it != cache.end(); it++) {
1311 0 : for (ArpProto::ArpEntrySet::iterator sit = it->second.begin();
1312 0 : sit != it->second.end(); sit++) {
1313 0 : arp_sandesh->SetArpEntry(it->first, *sit);
1314 : }
1315 : }
1316 :
1317 0 : arp_sandesh->Response();
1318 0 : delete arp_sandesh;
1319 0 : }
1320 :
1321 0 : bool ArpSandesh::SetArpEntry(const ArpKey &key, const ArpEntry *entry) {
1322 0 : ArpCacheResp *vresp = static_cast<ArpCacheResp *>(resp_);
1323 0 : ArpSandeshData data;
1324 0 : boost::asio::ip::address_v4 ip(key.ip);
1325 0 : data.set_ip(ip.to_string());
1326 0 : data.set_vrf(key.vrf->GetName());
1327 0 : if (entry->get_interface())
1328 0 : data.set_interface_name(entry->get_interface()->name());
1329 0 : std::string mac_str;
1330 0 : ServicesSandesh::MacToString(entry->mac_address(), mac_str);
1331 0 : data.set_mac(mac_str);
1332 0 : switch (entry->state()) {
1333 0 : case ArpEntry::INITING:
1334 0 : data.set_state("initing");
1335 0 : break;
1336 0 : case ArpEntry::RESOLVING:
1337 0 : data.set_state("resolving");
1338 0 : break;
1339 0 : case ArpEntry::ACTIVE:
1340 0 : data.set_state("active");
1341 0 : break;
1342 0 : case ArpEntry::RERESOLVING:
1343 0 : data.set_state("re-resolving");
1344 0 : break;
1345 : }
1346 :
1347 : std::vector<ArpSandeshData> &list =
1348 0 : const_cast<std::vector<ArpSandeshData>&>(vresp->get_arp_list());
1349 0 : list.push_back(data);
1350 0 : iter_++;
1351 0 : if (!(iter_ % ArpSandesh::entries_per_sandesh)) {
1352 : // send partial sandesh
1353 0 : ArpCacheResp *resp = new ArpCacheResp();
1354 0 : resp->set_context(resp_->context());
1355 0 : resp_->set_context(resp_->context());
1356 0 : resp_->set_more(true);
1357 0 : resp_->Response();
1358 0 : resp_ = resp;
1359 : }
1360 0 : return true;
1361 0 : }
1362 :
1363 0 : void ArpSandesh::SetInterfaceArpStatsEntry(
1364 : ArpProto::InterfaceArpMap::const_iterator &it,
1365 : std::vector<InterfaceArpStats> &list) {
1366 0 : InterfaceArpStats data;
1367 0 : data.set_interface_index(it->first);
1368 0 : data.set_arp_requests(it->second.stats.arp_req);
1369 0 : data.set_arp_replies(it->second.stats.arp_replies);
1370 0 : data.set_arp_resolved(it->second.stats.resolved);
1371 0 : list.push_back(data);
1372 0 : }
1373 :
1374 0 : void InterfaceArpStatsReq::HandleRequest() const {
1375 0 : InterfaceArpStatsResponse *resp = new InterfaceArpStatsResponse();
1376 0 : resp->set_context(context());
1377 0 : ArpSandesh arp_sandesh(resp);
1378 : const ArpProto::InterfaceArpMap &imap =
1379 0 : (Agent::GetInstance()->GetArpProto()->interface_arp_map());
1380 : std::vector<InterfaceArpStats> &list =
1381 0 : const_cast<std::vector<InterfaceArpStats>&>(resp->get_stats_list());
1382 0 : if (get_interface_index() != -1) {
1383 : ArpProto::InterfaceArpMap::const_iterator it = imap.find
1384 0 : (get_interface_index());
1385 0 : if (it != imap.end()) {
1386 0 : arp_sandesh.SetInterfaceArpStatsEntry(it, list);
1387 : }
1388 0 : arp_sandesh.Response();
1389 0 : return;
1390 : }
1391 0 : for (ArpProto::InterfaceArpMap::const_iterator it = imap.begin();
1392 0 : it != imap.end(); it++) {
1393 0 : arp_sandesh.SetInterfaceArpStatsEntry(it, list);
1394 : }
1395 0 : arp_sandesh.Response();
1396 : }
1397 :
1398 0 : void InterfaceIcmpv6StatsReq::HandleRequest() const {
1399 0 : Agent * agent = Agent::GetInstance();
1400 0 : InterfaceIcmpv6StatsResponse *resp = new InterfaceIcmpv6StatsResponse();
1401 0 : resp->set_context(context());
1402 : const Icmpv6Proto::VmInterfaceMap &imap =
1403 0 : (agent->icmpv6_proto()->vm_interfaces());
1404 : std::vector<InterfaceIcmpv6Stats> &list =
1405 0 : const_cast<std::vector<InterfaceIcmpv6Stats>&>(resp->get_stats_list());
1406 0 : if (get_interface_index() != -1) {
1407 : VmInterface *vm_intf = static_cast<VmInterface *>(
1408 0 : agent->interface_table()->FindInterface(get_interface_index()));
1409 0 : if (vm_intf) {
1410 0 : Icmpv6Proto::VmInterfaceMap::const_iterator it = imap.find(vm_intf);
1411 0 : if (it != imap.end()) {
1412 0 : SET_ICMPV6_INTERFACE_STATS(it, list);
1413 0 : }
1414 : }
1415 : } else {
1416 0 : for (Icmpv6Proto::VmInterfaceMap::const_iterator it = imap.begin();
1417 0 : it != imap.end(); it++) {
1418 0 : SET_ICMPV6_INTERFACE_STATS(it, list);
1419 0 : }
1420 : }
1421 0 : resp->Response();
1422 0 : }
|
