Annotation of embedaddon/pimd/trace.c, revision 1.1.1.1
1.1 misho 1: /*
2: * Copyright (c) 1998-2001
3: * University of Southern California/Information Sciences Institute.
4: * All rights reserved.
5: *
6: * Redistribution and use in source and binary forms, with or without
7: * modification, are permitted provided that the following conditions
8: * are met:
9: * 1. Redistributions of source code must retain the above copyright
10: * notice, this list of conditions and the following disclaimer.
11: * 2. Redistributions in binary form must reproduce the above copyright
12: * notice, this list of conditions and the following disclaimer in the
13: * documentation and/or other materials provided with the distribution.
14: * 3. Neither the name of the project nor the names of its contributors
15: * may be used to endorse or promote products derived from this software
16: * without specific prior written permission.
17: *
18: * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
19: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21: * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
22: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28: * SUCH DAMAGE.
29: */
30: /*
31: * $Id: trace.c,v 1.13 2002/09/26 00:59:30 pavlin Exp $
32: */
33: /*
34: * Part of this program has been derived from mrouted.
35: * The mrouted program is covered by the license in the accompanying file
36: * named "LICENSE.mrouted".
37: *
38: * The mrouted program is COPYRIGHT 1989 by The Board of Trustees of
39: * Leland Stanford Junior University.
40: *
41: */
42:
43:
44: #include "defs.h"
45: #include "trace.h"
46:
47:
48: /* TODO: XXX: implementation incompleted and buggy; check Kame's pim6sd */
49: /*
50: * Traceroute function which returns traceroute replies to the requesting
51: * router. Also forwards the request to downstream routers.
52: */
53: void accept_mtrace(uint32_t src, uint32_t dst, uint32_t group, char *data, u_int no, int datalen)
54: {
55: uint8_t type;
56: mrtentry_t *mrt;
57: struct tr_query *qry;
58: struct tr_resp *resp;
59: int vifi;
60: char *p;
61: u_int rcount;
62: int errcode = TR_NO_ERR;
63: int resptype;
64: struct timeval tp;
65: struct sioc_vif_req v_req;
66: #if 0
67: /* TODO */
68: struct sioc_sg_req sg_req;
69: #endif /* 0 */
70: uint32_t parent_address = INADDR_ANY;
71:
72: /* Remember qid across invocations */
73: static uint32_t oqid = 0;
74:
75: /* timestamp the request/response */
76: gettimeofday(&tp, 0);
77:
78: /*
79: * Check if it is a query or a response
80: */
81: if (datalen == QLEN) {
82: type = QUERY;
83: IF_DEBUG(DEBUG_TRACE) {
84: logit(LOG_DEBUG, 0, "Initial traceroute query rcvd from %s to %s",
85: inet_fmt(src, s1, sizeof(s1)), inet_fmt(dst, s2, sizeof(s2)));
86: }
87: } else if ((datalen - QLEN) % RLEN == 0) {
88: type = RESP;
89: IF_DEBUG(DEBUG_TRACE) {
90: logit(LOG_DEBUG, 0, "In-transit traceroute query rcvd from %s to %s",
91: inet_fmt(src, s1, sizeof(s1)), inet_fmt(dst, s2, sizeof(s2)));
92: }
93: if (IN_MULTICAST(ntohl(dst))) {
94: IF_DEBUG(DEBUG_TRACE) {
95: logit(LOG_DEBUG, 0, "Dropping multicast response");
96: }
97: return;
98: }
99: } else {
100: logit(LOG_WARNING, 0, "%s from %s to %s",
101: "Non decipherable traceroute request received",
102: inet_fmt(src, s1, sizeof(s1)), inet_fmt(dst, s2, sizeof(s2)));
103: return;
104: }
105:
106: qry = (struct tr_query *)data;
107:
108: /*
109: * if it is a packet with all reports filled, drop it
110: */
111: if ((rcount = (datalen - QLEN)/RLEN) == no) {
112: IF_DEBUG(DEBUG_TRACE)
113: logit(LOG_DEBUG, 0, "packet with all reports filled in");
114: return;
115: }
116:
117: IF_DEBUG(DEBUG_TRACE) {
118: logit(LOG_DEBUG, 0, "s: %s g: %s d: %s ", inet_fmt(qry->tr_src, s1, sizeof(s1)),
119: inet_fmt(group, s2, sizeof(s2)), inet_fmt(qry->tr_dst, s3, sizeof(s3)));
120: logit(LOG_DEBUG, 0, "rttl: %d rd: %s", qry->tr_rttl,
121: inet_fmt(qry->tr_raddr, s1, sizeof(s1)));
122: logit(LOG_DEBUG, 0, "rcount:%d, qid:%06x", rcount, qry->tr_qid);
123: }
124:
125: /* determine the routing table entry for this traceroute */
126: mrt = find_route(qry->tr_src, group, MRTF_SG | MRTF_WC | MRTF_PMBR,
127: DONT_CREATE);
128: IF_DEBUG(DEBUG_TRACE) {
129: if (mrt != (mrtentry_t *)NULL) {
130: if (mrt->upstream != (pim_nbr_entry_t *)NULL)
131: parent_address = mrt->upstream->address;
132: else
133: parent_address = INADDR_ANY;
134: logit(LOG_DEBUG, 0, "mrt parent vif: %d rtr: %s metric: %d",
135: mrt->incoming, inet_fmt(parent_address, s1, sizeof(s1)), mrt->metric);
136: /* TODO
137: logit(LOG_DEBUG, 0, "mrt origin %s",
138: RT_FMT(rt, s1));
139: */
140: } else {
141: logit(LOG_DEBUG, 0, "...no route");
142: }
143: }
144:
145: /*
146: * Query type packet - check if rte exists
147: * Check if the query destination is a vif connected to me.
148: * and if so, whether I should start response back
149: */
150: if (type == QUERY) {
151: if (oqid == qry->tr_qid) {
152: /*
153: * If the multicast router is a member of the group being
154: * queried, and the query is multicasted, then the router can
155: * recieve multiple copies of the same query. If we have already
156: * replied to this traceroute, just ignore it this time.
157: *
158: * This is not a total solution, but since if this fails you
159: * only get N copies, N <= the number of interfaces on the router,
160: * it is not fatal.
161: */
162: IF_DEBUG(DEBUG_TRACE) {
163: logit(LOG_DEBUG, 0, "ignoring duplicate traceroute packet");
164: }
165: return;
166: }
167:
168: if (!mrt) {
169: IF_DEBUG(DEBUG_TRACE) {
170: logit(LOG_DEBUG, 0, "Mcast traceroute: no route entry %s", inet_fmt(qry->tr_src, s1, sizeof(s1)));
171: }
172: if (IN_MULTICAST(ntohl(dst)))
173: return;
174: }
175:
176: vifi = find_vif_direct(qry->tr_dst);
177: if (vifi == NO_VIF) {
178: /* The traceroute destination is not on one of my subnet vifs. */
179: IF_DEBUG(DEBUG_TRACE) {
180: logit(LOG_DEBUG, 0, "Destination %s not an interface", inet_fmt(qry->tr_dst, s1, sizeof(s1)));
181: }
182: if (IN_MULTICAST(ntohl(dst)))
183: return;
184: errcode = TR_WRONG_IF;
185: } else if (mrt && !VIFM_ISSET(vifi, mrt->oifs)) {
186: IF_DEBUG(DEBUG_TRACE) {
187: logit(LOG_DEBUG, 0,
188: "Destination %s not on forwarding tree for src %s",
189: inet_fmt(qry->tr_dst, s1, sizeof(s1)), inet_fmt(qry->tr_src, s2, sizeof(s2)));
190: }
191: if (IN_MULTICAST(ntohl(dst)))
192: return;
193: errcode = TR_WRONG_IF;
194: }
195: } else {
196: /*
197: * determine which interface the packet came in on
198: * RESP packets travel hop-by-hop so this either traversed
199: * a tunnel or came from a directly attached mrouter.
200: */
201: vifi = find_vif_direct(src);
202: if (vifi == NO_VIF) {
203: IF_DEBUG(DEBUG_TRACE) {
204: logit(LOG_DEBUG, 0, "Wrong interface for packet");
205: }
206: errcode = TR_WRONG_IF;
207: }
208: }
209:
210: /* Now that we've decided to send a response, save the qid */
211: oqid = qry->tr_qid;
212:
213: IF_DEBUG(DEBUG_TRACE) {
214: logit(LOG_DEBUG, 0, "Sending traceroute response");
215: }
216:
217: /* copy the packet to the sending buffer */
218: p = igmp_send_buf + IP_IGMP_HEADER_LEN + IGMP_MINLEN;
219: bcopy(data, p, datalen);
220: p += datalen;
221:
222: /*
223: * If there is no room to insert our reply, coopt the previous hop
224: * error indication to relay this fact.
225: */
226: if (p + sizeof(struct tr_resp) > igmp_send_buf + SEND_BUF_SIZE) {
227: resp = (struct tr_resp *)p - 1;
228: resp->tr_rflags = TR_NO_SPACE;
229: mrt = NULL;
230: goto sendit;
231: }
232:
233: /*
234: * fill in initial response fields
235: */
236: resp = (struct tr_resp *)p;
237: memset(resp, 0, sizeof(struct tr_resp));
238: datalen += RLEN;
239:
240: resp->tr_qarr = htonl(((tp.tv_sec + JAN_1970) << 16) +
241: ((tp.tv_usec << 10) / 15625));
242: resp->tr_rproto = PROTO_PIM;
243: resp->tr_outaddr = (vifi == NO_VIF) ? dst : uvifs[vifi].uv_lcl_addr;
244: resp->tr_fttl = (vifi == NO_VIF) ? 0 : uvifs[vifi].uv_threshold;
245: resp->tr_rflags = errcode;
246:
247: /*
248: * obtain # of packets out on interface
249: */
250: v_req.vifi = vifi;
251: if (vifi != NO_VIF && ioctl(udp_socket, SIOCGETVIFCNT, (char *)&v_req) >= 0)
252: resp->tr_vifout = htonl(v_req.ocount);
253: else
254: resp->tr_vifout = 0xffffffff;
255:
256: /*
257: * fill in scoping & pruning information
258: */
259: /* TODO */
260: #if 0
261: if (mrt) {
262: for (gt = rt->rt_groups; gt; gt = gt->gt_next) {
263: if (gt->gt_mcastgrp >= group)
264: break;
265: }
266: } else {
267: gt = NULL;
268: }
269:
270: if (gt && gt->gt_mcastgrp == group) {
271: struct stable *st;
272:
273: for (st = gt->gt_srctbl; st; st = st->st_next) {
274: if (qry->tr_src == st->st_origin)
275: break;
276: }
277:
278: sg_req.src.s_addr = qry->tr_src;
279: sg_req.grp.s_addr = group;
280: if (st && st->st_ctime != 0 &&
281: ioctl(udp_socket, SIOCGETSGCNT, (char *)&sg_req) >= 0)
282: resp->tr_pktcnt = htonl(sg_req.pktcnt + st->st_savpkt);
283: else
284: resp->tr_pktcnt = htonl(st ? st->st_savpkt : 0xffffffff);
285:
286: if (VIFM_ISSET(vifi, gt->gt_scope)) {
287: resp->tr_rflags = TR_SCOPED;
288: } else if (gt->gt_prsent_timer) {
289: resp->tr_rflags = TR_PRUNED;
290: } else if (!VIFM_ISSET(vifi, gt->gt_grpmems)) {
291: if (VIFM_ISSET(vifi, rt->rt_children) &&
292: NBRM_ISSETMASK(uvifs[vifi].uv_nbrmap, rt->rt_subordinates)) /*XXX*/
293: resp->tr_rflags = TR_OPRUNED;
294: else
295: resp->tr_rflags = TR_NO_FWD;
296: }
297: } else {
298: if (scoped_addr(vifi, group))
299: resp->tr_rflags = TR_SCOPED;
300: else if (rt && !VIFM_ISSET(vifi, rt->rt_children))
301: resp->tr_rflags = TR_NO_FWD;
302: }
303: #endif /* 0 */
304:
305: /*
306: * if no rte exists, set NO_RTE error
307: */
308: if (!mrt) {
309: src = dst; /* the dst address of resp. pkt */
310: resp->tr_inaddr = 0;
311: resp->tr_rflags = TR_NO_RTE;
312: resp->tr_rmtaddr = 0;
313: } else {
314: /* get # of packets in on interface */
315: v_req.vifi = mrt->incoming;
316: if (ioctl(udp_socket, SIOCGETVIFCNT, (char *)&v_req) >= 0)
317: resp->tr_vifin = htonl(v_req.icount);
318: else
319: resp->tr_vifin = 0xffffffff;
320:
321: /* TODO
322: MASK_TO_VAL(rt->rt_originmask, resp->tr_smask);
323: */
324: src = uvifs[mrt->incoming].uv_lcl_addr;
325: resp->tr_inaddr = src;
326: if (mrt->upstream)
327: parent_address = mrt->upstream->address;
328: else
329: parent_address = INADDR_ANY;
330:
331: resp->tr_rmtaddr = parent_address;
332: if (vifi != NO_VIF && !VIFM_ISSET(vifi, mrt->oifs)) {
333: IF_DEBUG(DEBUG_TRACE)
334: logit(LOG_DEBUG, 0, "Destination %s not on forwarding tree for src %s",
335: inet_fmt(qry->tr_dst, s1, sizeof(s1)), inet_fmt(qry->tr_src, s2, sizeof(s2)));
336: resp->tr_rflags = TR_WRONG_IF;
337: }
338: #if 0
339: if (rt->rt_metric >= UNREACHABLE) {
340: resp->tr_rflags = TR_NO_RTE;
341: /* Hack to send reply directly */
342: rt = NULL;
343: }
344: #endif /* 0 */
345: }
346:
347: sendit:
348: /*
349: * if metric is 1 or no. of reports is 1, send response to requestor
350: * else send to upstream router. If the upstream router can't handle
351: * mtrace, set an error code and send to requestor anyway.
352: */
353: IF_DEBUG(DEBUG_TRACE)
354: logit(LOG_DEBUG, 0, "rcount:%d, no:%d", rcount, no);
355:
356: if ((rcount + 1 == no) || (mrt == NULL) || (mrt->metric == 1)) {
357: resptype = IGMP_MTRACE_RESP;
358: dst = qry->tr_raddr;
359: } else {
360: #if 0 /* TODO */
361: if (!can_mtrace(rt->rt_parent, rt->rt_gateway)) {
362: dst = qry->tr_raddr;
363: resp->tr_rflags = TR_OLD_ROUTER;
364: resptype = IGMP_MTRACE_RESP;
365: } else {
366: #endif /* 0 */
367: if (mrt->upstream)
368: parent_address = mrt->upstream->address;
369: else
370: parent_address = INADDR_ANY;
371: dst = parent_address;
372: resptype = IGMP_MTRACE;
373: #if 0 /* TODO */
374: }
375: #endif
376: }
377:
378: if (IN_MULTICAST(ntohl(dst))) {
379: /*
380: * Send the reply on a known multicast capable vif.
381: * If we don't have one, we can't source any multicasts anyway.
382: */
383: if (phys_vif != -1) {
384: IF_DEBUG(DEBUG_TRACE)
385: logit(LOG_DEBUG, 0, "Sending reply to %s from %s",
386: inet_fmt(dst, s1, sizeof(s1)),
387: inet_fmt(uvifs[phys_vif].uv_lcl_addr, s2, sizeof(s2)));
388: k_set_ttl(igmp_socket, qry->tr_rttl);
389: send_igmp(igmp_send_buf, uvifs[phys_vif].uv_lcl_addr, dst,
390: resptype, no, group, datalen);
391: k_set_ttl(igmp_socket, 1);
392: } else {
393: logit(LOG_INFO, 0, "No enabled phyints -- dropping traceroute reply");
394: }
395: } else {
396: IF_DEBUG(DEBUG_TRACE) {
397: logit(LOG_DEBUG, 0, "Sending %s to %s from %s",
398: resptype == IGMP_MTRACE_RESP ? "reply" : "request on",
399: inet_fmt(dst, s1, sizeof(s1)), inet_fmt(src, s2, sizeof(s2)));
400: }
401: send_igmp(igmp_send_buf, src, dst, resptype, no, group, datalen);
402: }
403: }
404:
405:
406: /*
407: * accept_neighbor_request() supports some old DVMRP messages from mrinfo.
408: * Haven't tested it, because I have only the new mrinfo.
409: */
410: void accept_neighbor_request(uint32_t src, uint32_t dst __attribute__((unused)))
411: {
412: vifi_t vifi;
413: struct uvif *v;
414: uint8_t *p, *ncount;
415: /* struct listaddr *la; */
416: pim_nbr_entry_t *pim_nbr;
417: int datalen;
418: uint32_t temp_addr, them = src;
419:
420: #define PUT_ADDR(a) temp_addr = ntohl(a); \
421: *p++ = temp_addr >> 24; \
422: *p++ = (temp_addr >> 16) & 0xFF; \
423: *p++ = (temp_addr >> 8) & 0xFF; \
424: *p++ = temp_addr & 0xFF;
425:
426: p = (uint8_t *) (igmp_send_buf + IP_IGMP_HEADER_LEN + IGMP_MINLEN);
427: datalen = 0;
428:
429: for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) {
430: if (v->uv_flags & VIFF_DISABLED)
431: continue;
432:
433: ncount = 0;
434:
435: /* TODO: XXX: if we are PMBR, then check the DVMRP interfaces too */
436: for (pim_nbr = v->uv_pim_neighbors; pim_nbr != (pim_nbr_entry_t *)NULL;
437: pim_nbr = pim_nbr->next) {
438: /* Make sure that there's room for this neighbor... */
439: if (datalen + (ncount == 0 ? 4 + 3 + 4 : 4) > MAX_DVMRP_DATA_LEN) {
440: send_igmp(igmp_send_buf, INADDR_ANY, them, IGMP_DVMRP,
441: DVMRP_NEIGHBORS, htonl(PIMD_LEVEL), datalen);
442: p = (uint8_t *) (igmp_send_buf + IP_IGMP_HEADER_LEN + IGMP_MINLEN);
443: datalen = 0;
444: ncount = 0;
445: }
446:
447: /* Put out the header for this neighbor list... */
448: if (ncount == 0) {
449: PUT_ADDR(v->uv_lcl_addr);
450: *p++ = v->uv_metric;
451: *p++ = v->uv_threshold;
452: ncount = p;
453: *p++ = 0;
454: datalen += 4 + 3;
455: }
456:
457: PUT_ADDR(pim_nbr->address);
458: datalen += 4;
459: (*ncount)++;
460: }
461: }
462:
463: if (datalen != 0)
464: send_igmp(igmp_send_buf, INADDR_ANY, them, IGMP_DVMRP, DVMRP_NEIGHBORS,
465: htonl(PIMD_LEVEL), datalen);
466: }
467:
468:
469: /*
470: * Send a list of all of our neighbors to the requestor, `src'.
471: * Used for mrinfo support.
472: * XXX: currently, we cannot specify the used multicast routing protocol;
473: * only a protocol version is returned.
474: */
475: void accept_neighbor_request2(uint32_t src, uint32_t dst __attribute__((unused)))
476: {
477: vifi_t vifi;
478: struct uvif *v;
479: uint8_t *p, *ncount;
480: /* struct listaddr *la; */
481: pim_nbr_entry_t *pim_nbr;
482: int datalen;
483: uint32_t them = src;
484:
485: p = (uint8_t *) (igmp_send_buf + IP_IGMP_HEADER_LEN + IGMP_MINLEN);
486: datalen = 0;
487:
488: for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) {
489: uint32_t vflags = v->uv_flags;
490: uint8_t rflags = 0;
491:
492: if (vflags & VIFF_TUNNEL)
493: rflags |= DVMRP_NF_TUNNEL;
494: if (vflags & VIFF_SRCRT)
495: rflags |= DVMRP_NF_SRCRT;
496: if (vflags & VIFF_PIM_NBR)
497: rflags |= DVMRP_NF_PIM;
498: if (vflags & VIFF_DOWN)
499: rflags |= DVMRP_NF_DOWN;
500: if (vflags & VIFF_DISABLED)
501: rflags |= DVMRP_NF_DISABLED;
502: if (vflags & VIFF_QUERIER)
503: rflags |= DVMRP_NF_QUERIER;
504: if (vflags & VIFF_LEAF)
505: rflags |= DVMRP_NF_LEAF;
506:
507: ncount = 0;
508: pim_nbr = v->uv_pim_neighbors;
509: if (pim_nbr == (pim_nbr_entry_t *)NULL) {
510: /*
511: * include down & disabled interfaces and interfaces on
512: * leaf nets.
513: */
514: if (rflags & DVMRP_NF_TUNNEL)
515: rflags |= DVMRP_NF_DOWN;
516:
517: if (datalen > MAX_DVMRP_DATA_LEN - 12) {
518: send_igmp(igmp_send_buf, INADDR_ANY, them, IGMP_DVMRP,
519: DVMRP_NEIGHBORS2, htonl(PIMD_LEVEL), datalen);
520: p = (uint8_t *) (igmp_send_buf + IP_IGMP_HEADER_LEN + IGMP_MINLEN);
521: datalen = 0;
522: }
523:
524: *(u_int*)p = v->uv_lcl_addr;
525: p += 4;
526: *p++ = v->uv_metric;
527: *p++ = v->uv_threshold;
528: *p++ = rflags;
529: *p++ = 1;
530: *(u_int*)p = v->uv_rmt_addr;
531: p += 4;
532: datalen += 12;
533: } else {
534: for ( ; pim_nbr; pim_nbr = pim_nbr->next) {
535: /* Make sure that there's room for this neighbor... */
536: if (datalen + (ncount == 0 ? 4+4+4 : 4) > MAX_DVMRP_DATA_LEN) {
537: send_igmp(igmp_send_buf, INADDR_ANY, them, IGMP_DVMRP,
538: DVMRP_NEIGHBORS2, htonl(PIMD_LEVEL), datalen);
539: p = (uint8_t *) (igmp_send_buf + IP_IGMP_HEADER_LEN + IGMP_MINLEN);
540: datalen = 0;
541: ncount = 0;
542: }
543:
544: /* Put out the header for this neighbor list... */
545: if (ncount == 0) {
546: *(u_int*)p = v->uv_lcl_addr;
547: p += 4;
548: *p++ = v->uv_metric;
549: *p++ = v->uv_threshold;
550: *p++ = rflags;
551: ncount = p;
552: *p++ = 0;
553: datalen += 4 + 4;
554: }
555:
556: *(u_int*)p = pim_nbr->address;
557: p += 4;
558: datalen += 4;
559: (*ncount)++;
560: }
561: }
562: }
563:
564: if (datalen != 0)
565: send_igmp(igmp_send_buf, INADDR_ANY, them, IGMP_DVMRP,
566: DVMRP_NEIGHBORS2, htonl(PIMD_LEVEL), datalen);
567: }
568:
569: /**
570: * Local Variables:
571: * version-control: t
572: * indent-tabs-mode: t
573: * c-file-style: "ellemtel"
574: * c-basic-offset: 4
575: * End:
576: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to trace.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pimd