pool/openslp
SHA256
4
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
openslp/extensions.diff

4045 lines
121 KiB
Diff
Raw Blame History

--- ./common/Makefile.am.orig 2003-02-13 05:19:57.000000000 +0000
+++ ./common/Makefile.am 2006-11-16 16:19:30.000000000 +0000
@@ -24,6 +24,7 @@ libcommonlibslp_la_SOURCES = \
slp_parse.c \
slp_pid.c \
slp_dhcp.c \
+ slp_mdns.c \
$(slp_v1message_SRCS) \
$(slp_security_SRCS)
@@ -46,6 +47,7 @@ libcommonslpd_la_SOURCES = \
slp_filter_l.l \
slp_predicate.c \
slp_dhcp.c \
+ slp_mdns.c \
$(slp_v1message_SRCS) \
$(slp_security_SRCS)
@@ -75,6 +77,7 @@ noinst_HEADERS = \
slp_filter.h \
slp_filter_y.h \
slp_predicate.h \
+ slp_mdns.h \
slp_dhcp.h
AM_YFLAGS = -d
--- ./common/slp_compare.c.orig 2002-12-03 21:04:49.000000000 +0000
+++ ./common/slp_compare.c 2006-11-16 16:19:30.000000000 +0000
@@ -146,6 +146,17 @@ int SLPCompareNamingAuth(int srvtypelen,
if(namingauthlen == 0xffff) /* match all naming authorities */
return 0;
+ /* Skip "service:" */
+ if(srvtypelen > 8 && strncasecmp(srvtype,"service:",8) == 0)
+ {
+ srvtypelen -= 8;
+ srvtype += 8;
+ }
+ dot = memchr(srvtype,':',srvtypelen);
+ if (dot)
+ {
+ srvtypelen = dot - srvtype;
+ }
dot = memchr(srvtype,'.',srvtypelen);
if(!namingauthlen) /* IANA naming authority */
--- ./common/slp_mdns.c.orig 2006-11-16 16:19:30.000000000 +0000
+++ ./common/slp_mdns.c 2006-11-16 16:19:30.000000000 +0000
@@ -0,0 +1,573 @@
+#include "slp_mdns.h"
+#include "slp_message.h"
+
+
+#ifdef DEBUG
+
+#include <stdio.h>
+
+unsigned char *SLPMDNSDumpN(unsigned char *bp, unsigned char *start)
+{
+ unsigned char *obp = 0;
+ int x;
+
+ for (;;) {
+ if ((*bp & 0xc0) == 0xc0) {
+ if (!obp)
+ obp = bp + 2;
+ x = (*bp & 0x3f) << 8 | bp[1];
+ printf("%d:", x);
+ bp = start + x;
+ }
+ if (!*bp) {
+ printf("0");
+ return obp ? obp : bp + 1;
+ }
+ printf("%d ", *bp);
+ fwrite(bp + 1, *bp, 1, stdout);
+ printf(" ");
+ bp += *bp + 1;
+ }
+}
+
+unsigned char *SLPMDNSDumpRR(unsigned char *start, unsigned char *bp)
+{
+ int t, l, l2;
+ printf(" ");
+ bp = SLPMDNSDumpN(bp, start);
+ t = AsUINT16(bp);
+ printf(" TYPE=%d CLASS=%d TTL=%d", t, AsUINT16(bp + 2), AsUINT32(bp + 4));
+ l = AsUINT16(bp + 8);
+ bp += 10;
+ if (t == DNS_TYPE_A)
+ printf(" A=%d.%d.%d.%d", bp[0], bp[1], bp[2], bp[3]);
+ else if (t == DNS_TYPE_AAAA)
+ printf(" AAAA=%02x.%02x.%02x.%02x....", bp[0], bp[1], bp[2], bp[3]);
+ else if (t == DNS_TYPE_PTR)
+ {
+ putchar(' ');
+ SLPMDNSDumpN(bp, start);
+ }
+ else if (t == DNS_TYPE_SRV)
+ {
+ printf(" PRIO=%d WEIGHT=%d PORT=%d ", AsUINT16(bp), AsUINT16(bp + 2), AsUINT16(bp + 4));
+ SLPMDNSDumpN(bp + 6, start);
+ }
+ else if (t == DNS_TYPE_TXT)
+ {
+ while (l > 0)
+ {
+ l2 = *bp++;
+ l--;
+ putchar(' ');
+ putchar('"');
+ while (l2-- > 0 && l > 0)
+ {
+ putchar(*bp++);
+ l--;
+ }
+ putchar('"');
+ }
+ }
+ else
+ {
+ while (l > 0)
+ {
+ printf(" %02x", *bp++);
+ l--;
+ }
+ }
+ printf("\n");
+ return bp + l;
+}
+
+void SLPMDNSDumpDNS(SLPBuffer buf, char *head)
+{
+ int qcount, acount, ncount, xcount;
+ unsigned char *start = (unsigned char *)buf->start;
+ unsigned char *bp = start;
+
+ printf("%s DNS buffer\n", head);
+ printf(" ID %04x", AsUINT16(bp));
+ printf(" Flags %04x\n", AsUINT16(bp + 2));
+ qcount = AsUINT16(bp + 4);
+ acount = AsUINT16(bp + 6);
+ ncount = AsUINT16(bp + 8);
+ xcount = AsUINT16(bp + 10);
+ printf(" QCount %d\n", qcount);
+ bp += 12;
+ while (qcount-- > 0) {
+ printf(" ");
+ bp = SLPMDNSDumpN(bp, start);
+ printf(" TYPE=%d CLASS=%d\n", AsUINT16(bp), AsUINT16(bp + 2));
+ bp += 4;
+ }
+ printf(" ACount %d\n", acount);
+ while (acount-- > 0) {
+ bp = SLPMDNSDumpRR(start, bp);
+ }
+ printf(" NCount %d\n", ncount);
+ while (ncount-- > 0) {
+ bp = SLPMDNSDumpRR(start, bp);
+ }
+ printf(" XCount %d\n", xcount);
+ while (xcount-- > 0) {
+ bp = SLPMDNSDumpRR(start, bp);
+ }
+ printf("\n");
+}
+
+void SLPMDNSDumpBuf(unsigned char *buf, int len)
+{
+ int i;
+ while (len > 0)
+ {
+ for (i = 0; i < 16; i++)
+ {
+ if (i < len)
+ printf(" %02x", buf[i]);
+ else
+ printf(" ");
+ }
+ printf(" ");
+ for (i = 0; i < 16; i++)
+ {
+ if (i < len)
+ putchar(buf[i] >= 32 && buf[i] < 127 ? buf[i] : '.');
+ else
+ break;
+ }
+ putchar('\n');
+ len -= 16;
+ buf += 16;
+ }
+}
+
+#endif
+
+unsigned char *SLPMDNSParseRR(unsigned char *bp, unsigned char *end,
+ int count,
+ unsigned char **dn,
+ unsigned char **dd, int *dc)
+{
+ int c = 0;
+ for (; count > 0; count--)
+ {
+ if (dn && c < SLP_MDNS_MAX_RR)
+ dn[c] = bp;
+ while (bp < end && *bp && (*bp & 0xc0) != 0xc0)
+ bp += *bp + 1;
+ if (bp < end && *bp)
+ bp++;
+ if (bp + 11 > end)
+ return end + 1;
+ if (dd && c < SLP_MDNS_MAX_RR)
+ dd[c++] = bp + 1;
+ bp += 11 + AsUINT16((char *)bp + 9);
+ }
+ if (dc)
+ *dc = c;
+ return bp;
+}
+
+int SLPMDNSCheckN(unsigned char *r,
+ unsigned char *e,
+ unsigned char *a,
+ int ini)
+{
+ int l = 0;
+
+ for (;;)
+ {
+ if (a < r || a >= e)
+ return 1;
+ if ((*a & 0xc0) == 0xc0)
+ {
+ ini = 0;
+ a = r + ((*a & 0x3f) << 8 | a[1]);
+ if (a < r || a >= e)
+ return 1;
+ }
+ if (!*a)
+ return 0;
+ if ((*a & 0xc0) != 0)
+ return 1;
+ l += *a + 1;
+ if (ini && ini < l + 1)
+ return 1;
+ a += *a + 1;
+ if (l > 254)
+ return 1;
+ }
+}
+
+int SLPMDNSCheckRR(unsigned char *r,
+ unsigned char *e,
+ unsigned char **dn,
+ unsigned char **dd, int *dc)
+{
+ int i, j, c, t, l;
+
+ c = *dc;
+ for (i = j = 0; i < c; i++)
+ {
+ if (SLPMDNSCheckN(r, e, dn[i], 0))
+ continue;
+ t = AsUINT16(dd[i]);
+ l = AsUINT16(dd[i] + 8);
+ if (t == DNS_TYPE_PTR)
+ {
+ if (l < 1)
+ continue;
+ if (SLPMDNSCheckN(r, e, dd[i] + 10, l))
+ continue;
+ }
+ else if (t == DNS_TYPE_A)
+ {
+ if (l < 4)
+ continue;
+ }
+ else if (t == DNS_TYPE_AAAA)
+ {
+ if (l < 16)
+ continue;
+ }
+ else if (t == DNS_TYPE_SRV)
+ {
+ if (l < 7)
+ continue;
+ if (SLPMDNSCheckN(r, e, dd[i] + 16, l - 6))
+ continue;
+ }
+ if (j < i)
+ {
+ dn[j] = dn[i];
+ dd[j] = dd[i];
+ }
+ j++;
+ }
+ *dc = j;
+ return i == j ? 0 : 1;
+}
+
+int SLPMDNSCmpN(unsigned char *a, unsigned char *ar,
+ unsigned char *b, unsigned char *br)
+{
+ for (;;)
+ {
+ if ((*a & 0xc0) == 0xc0)
+ a = ar + ((*a & 0x3f) << 8 | a[1]);
+ if ((*b & 0xc0) == 0xc0)
+ b = br + ((*b & 0x3f) << 8 | b[1]);
+ if (*a != *b)
+ return 1;
+ if (*a == 0)
+ return 0;
+ if (memcmp(a + 1, b + 1, *a))
+ return 1;
+ a += *a + 1;
+ b += *b + 1;
+ }
+}
+
+unsigned char *SLPMDNSCompN(unsigned char *bp, unsigned char *end,
+ unsigned char *a, unsigned char *ar,
+ unsigned char **cvec, int *ncvecp,
+ unsigned char *r)
+{
+ int i;
+ unsigned char *first = 0;
+ int ncvec = ncvecp ? *ncvecp : 0;
+
+ for (;;)
+ {
+ if ((*a & 0xc0) == 0xc0)
+ a = ar + ((*a & 0x3f) << 8 | a[1]);
+ if ((*a & 0xc0) == 0xc0)
+ return 0;
+ if (*a)
+ {
+ for (i = 0; i < ncvec; i++)
+ if (!SLPMDNSCmpN(a, ar, cvec[i], r))
+ break;
+ if (i < ncvec)
+ {
+ if (bp + 1 >= end)
+ return 0;
+ *bp++ = (cvec[i] - r) >> 8 | 0xc0;
+ *bp++ = (cvec[i] - r) & 0xff;
+ break;
+ }
+ }
+ if (first == 0 && *a)
+ first = bp;
+ if (bp + *a + 1 >= end)
+ return 0;
+ memcpy(bp, a, *a + 1);
+ bp += *a + 1;
+ if (*a == 0)
+ break;
+ a += *a + 1;
+ }
+ if (first && ncvecp && ncvec < 256)
+ {
+ cvec[ncvec] = first;
+ *ncvecp = ncvec + 1;
+ }
+ return bp;
+}
+
+unsigned char *SLPMDNSNToStr(unsigned char *bp, unsigned char *end,
+ unsigned char *a, unsigned char *ar, int nolastdot)
+{
+ if (!*a && bp < end)
+ *bp++ = '.';
+ for (;;)
+ {
+ if ((*a & 0xc0) == 0xc0)
+ a = ar + ((*a & 0x3f) << 8 | a[1]);
+ if (*a >= 64 || bp + *a >= end)
+ return 0;
+ if (!*a)
+ break;
+ memcpy(bp, a + 1, *a);
+ bp += *a;
+ a += *a + 1;
+ if (!nolastdot || *a)
+ *bp++ = '.';
+ }
+ return bp;
+}
+
+unsigned char *MDNSStrToN(unsigned char *bp, unsigned char *end,
+ const char *str, int len)
+{
+ unsigned char *op;
+
+ for (op = ++bp; ; str++, len--)
+ {
+ if (bp >= end)
+ return 0;
+ if (len == 0 || *str == '.')
+ {
+ if (bp != op)
+ {
+ if (bp - op >= 64)
+ return 0;
+ op[-1] = bp - op;
+ op = ++bp;
+ }
+ if (len == 0)
+ break;
+ continue;
+ }
+ *bp++ = *str;
+ }
+ bp[-1] = 0;
+ return bp;
+}
+
+unsigned char *SLPMDNSCopyN(unsigned char *bp, unsigned char *end, unsigned char *a, unsigned char *ar)
+{
+ for (;;)
+ {
+ if ((*a & 0xc0) == 0xc0)
+ a = ar + ((*a & 0x3f) << 8 | a[1]);
+ if (bp + *a + 1 > end)
+ return 0;
+ memcpy(bp, a, *a + 1);
+ bp += *a + 1;
+ if (!*a)
+ return bp;
+ a += *a + 1;
+ }
+}
+
+unsigned char *SLPMDNSAddRR(unsigned char *bp, unsigned char *start,
+ unsigned char *end,
+ unsigned char *q, unsigned char *qr,
+ int type,
+ int ttl,
+ unsigned char **cvec,
+ int *ncvec,
+ int data1,
+ unsigned char *data2,
+ unsigned char **dp)
+{
+ unsigned char *oldbp;
+
+ bp = SLPMDNSCompN(bp, end, q, qr, cvec, ncvec, start);
+ if (!bp || bp + 10 > end)
+ return 0;
+ ToUINT16(bp, type);
+ ToUINT16(bp + 2, DNS_CLASS_IN);
+ ToUINT32(bp + 4, ttl);
+ bp += 10;
+ oldbp = bp;
+ if (type == DNS_TYPE_PTR)
+ {
+ bp = SLPMDNSCompN(bp, end, data2, qr, cvec, ncvec, start);
+ if (!bp)
+ return 0;
+ }
+ else if (type == DNS_TYPE_A)
+ {
+ if (bp + 4 > end)
+ return 0;
+ memcpy(bp, data2, 4);
+ bp += 4;
+ }
+ else if (type == DNS_TYPE_TXT)
+ {
+ if (bp + data1 > end)
+ return 0;
+ memcpy(bp, data2, data1);
+ bp += data1;
+ }
+ else if (type == DNS_TYPE_SRV)
+ {
+ if (bp + 6 > end)
+ return 0;
+ ToUINT16(bp, 0);
+ ToUINT16(bp + 2, 0);
+ ToUINT16(bp + 4, data1);
+ /* rfc says target is not compressed */
+ bp = SLPMDNSCopyN(bp + 6, end, data2, 0);
+ if (!bp)
+ return 0;
+ }
+ else
+ return 0;
+ ToUINT16(oldbp - 2, bp - oldbp);
+ if (dp)
+ *dp = oldbp - 10;
+ return bp;
+}
+
+int SLPMDNSNToSrvtype(unsigned char *a, unsigned char *ar, char *buf, int len)
+{
+ char *sp;
+ int l, l2;
+
+ if (len < 9)
+ return 0;
+ memcpy(buf, "service", 8);
+ sp = buf + 7;
+ len -= 7;
+ l2 = 1; /* the \0 */
+ for (;;)
+ {
+ if ((*a & 0xc0) == 0xc0)
+ a = ar + ((*a & 0x3f) << 8 | a[1]);
+ l = *a++;
+ if (l == 0)
+ break;
+ if (l == 4 && (!strncasecmp(a, "_tcp", 4) || !strncasecmp(a, "_udp", 4)))
+ break;
+ if (*a == '_' && l > 1)
+ {
+ a++;
+ l--;
+ }
+ if (l2 + l + 1 > len)
+ return 0; /* doesn't fit */
+ memmove(sp + l + 1, sp, l2);
+ l2 += l + 1;
+ *sp++ = ':';
+ for (; l-- > 0; a++)
+ *sp++ = *a != ':' ? *a : '.';
+ sp = buf + 7;
+ }
+ sp += l2 - 1;
+ if (l2 == 1)
+ {
+ *sp++ = ':';
+ *sp = 0;
+ }
+ return sp - buf;
+}
+
+unsigned char *SLPMDNSSrvtypeToN(unsigned char *bp, unsigned char *end, const char *buf, int len)
+{
+ int l, l2;
+ unsigned char *bb;
+ char *p;
+
+ if (len > 8 && !strncasecmp(buf, "service:", 8))
+ {
+ len -= 8;
+ buf += 8;
+ }
+ if (len <= 0)
+ return 0;
+ l2 = 0;
+ for (;;)
+ {
+ p = memchr(buf, ':', len);
+ l = p ? p - buf : len;
+ if (l >= 63 || bp + l2 + l + 2 > end)
+ return 0;
+ if (l2)
+ memmove(bp + l + 2, bp, l2);
+ l2 += l + 2;
+ bb = bp;
+ *bp++ = l + 1;
+ *bp++ = '_';
+ for (; l > 0; l--)
+ {
+ *bp++ = *buf != '.' ? *buf : ':';
+ buf++;
+ len--;
+ }
+ bp = bb;
+ if (!p)
+ break;
+ buf++;
+ len--;
+ }
+ bp += l2;
+ if (bp + 12 > end)
+ return 0;
+ memcpy(bp, "\004_tcp\005local\000", 12);
+ return bp + 12;
+}
+
+char *SLPMDNSFindInTxt(unsigned char *txtbuf, int txtlen, char *name, int *valuelen)
+{
+ int namelen;
+ int l;
+
+ namelen = strlen(name);
+ while (txtlen >= namelen + 1)
+ {
+ l = *txtbuf++;
+ if (l >= namelen && !memcmp(txtbuf, name, namelen))
+ {
+ *valuelen = l - namelen;
+ return txtbuf + namelen;
+ }
+ txtbuf += l;
+ txtlen -= l + 1;
+ }
+ return 0;
+}
+
+int SLPMDNSAddTxt(unsigned char *txtbuf, int buflen, int *txtlenp, const char *name, const char *value, int valuelen)
+{
+ int txtlen = *txtlenp;
+ int namelen;
+ char *tp;
+
+ namelen = strlen(name);
+ if (namelen + valuelen > 255)
+ return 1;
+ if (txtlen + 1 + namelen + valuelen > buflen)
+ return 1;
+ tp = txtbuf + txtlen;
+ *tp++ = namelen + valuelen;
+ memcpy(tp, name, namelen);
+ memcpy(tp + namelen, value, valuelen);
+ *txtlenp = txtlen + 1 + namelen + valuelen;
+ return 0;
+}
+
--- ./common/slp_mdns.h.orig 2006-11-16 16:19:30.000000000 +0000
+++ ./common/slp_mdns.h 2006-11-16 16:19:30.000000000 +0000
@@ -0,0 +1,102 @@
+#ifndef SLP_MDNS_H_INCLUDED
+#define SLP_MDNS_H_INCLUDED
+
+#include "slp_buffer.h"
+
+#define MDNS_RESERVED_PORT 5353
+#define MDNS_MCAST_ADDRESS 0xe00000fb
+
+#define DNS_TYPE_A 1
+#define DNS_TYPE_PTR 12
+#define DNS_TYPE_HINFO 13
+#define DNS_TYPE_TXT 16
+#define DNS_TYPE_AAAA 28
+#define DNS_TYPE_SRV 33
+#define DNS_TYPE_ANY 255
+
+#define DNS_CLASS_IN 1
+#define DNS_CLASS_ANY 255
+
+#define SLP_MDNS_MAX_RR 128
+
+#ifdef DEBUG
+
+extern unsigned char *SLPMDNSDumpN(unsigned char *bp,
+ unsigned char *start);
+extern unsigned char *SLPMDNSDumpRR(unsigned char *start,
+ unsigned char *bp);
+extern void SLPMDNSDumpDNS(SLPBuffer buf,
+ char *head);
+extern void SLPMDNSDumpBuf(unsigned char *buf,
+ int len);
+#endif
+
+extern unsigned char *SLPMDNSParseRR(unsigned char *bp,
+ unsigned char *end,
+ int count,
+ unsigned char **dn,
+ unsigned char **dd,
+ int *dc);
+extern int SLPMDNSCheckN(unsigned char *r,
+ unsigned char *e,
+ unsigned char *a,
+ int ini);
+extern int SLPMDNSCheckRR(unsigned char *r,
+ unsigned char *e,
+ unsigned char **dn,
+ unsigned char **dd, int *dc);
+extern int SLPMDNSCmpN(unsigned char *a,
+ unsigned char *ar,
+ unsigned char *b,
+ unsigned char *br);
+extern unsigned char *SLPMDNSCompN(unsigned char *bp,
+ unsigned char *end,
+ unsigned char *a,
+ unsigned char *ar,
+ unsigned char **cvec,
+ int *ncvecp,
+ unsigned char *r);
+extern unsigned char *SLPMDNSNToStr(unsigned char *bp,
+ unsigned char *end,
+ unsigned char *a,
+ unsigned char *ar,
+ int nolastdot);
+extern unsigned char *MDNSStrToN(unsigned char *bp,
+ unsigned char *end,
+ const char *str,
+ int len);
+extern unsigned char *SLPMDNSCopyN(unsigned char *bp,
+ unsigned char *end,
+ unsigned char *a,
+ unsigned char *ar);
+extern unsigned char *SLPMDNSAddRR(unsigned char *bp,
+ unsigned char *start,
+ unsigned char *end,
+ unsigned char *q, unsigned char *qr,
+ int type,
+ int ttl,
+ unsigned char **cvec,
+ int *ncvec,
+ int data1,
+ unsigned char *data2,
+ unsigned char **dp);
+extern int SLPMDNSNToSrvtype(unsigned char *a,
+ unsigned char *ar,
+ char *buf,
+ int len);
+extern unsigned char *SLPMDNSSrvtypeToN(unsigned char *bp,
+ unsigned char *end,
+ const char *buf,
+ int len);
+extern char *SLPMDNSFindInTxt(unsigned char *txtbuf,
+ int txtlen,
+ char *name,
+ int *valuelen);
+extern int SLPMDNSAddTxt(unsigned char *txtbuf,
+ int buflen,
+ int *txtlenp,
+ const char *name,
+ const char *value,
+ int valuelen);
+
+#endif
--- ./common/slp_message.h.orig 2003-04-04 06:52:07.000000000 +0000
+++ ./common/slp_message.h 2006-11-16 16:19:30.000000000 +0000
@@ -170,6 +170,10 @@ typedef UINT32* PUINT32;
#define SLP_REG_SOURCE_LOCAL 2 /* from localhost or IPC */
#define SLP_REG_SOURCE_STATIC 3 /* from the slp.reg file */
+#define SLP_REG_WATCH_TCP (1<<0)
+#define SLP_REG_WATCH_UDP (1<<1)
+#define SLP_REG_WATCH_CHECKING (1<<8)
+#define SLP_REG_WATCH_DEAD (1<<9)
/*=========================================================================*/
/* SLP Extension IDs */
@@ -274,6 +278,8 @@ typedef struct _SLPSrvReg
SLPAuthBlock* autharray;
/* The following are used for OpenSLP specific extensions */
uint32_t pid;
+ int watchport;
+ int watchflags;
/* The following are not part of the RFC protocol. They are used by */
/* the OpenSLP implementation for convenience */
int source;
--- ./common/slp_net.c.orig 2006-11-16 16:19:17.000000000 +0000
+++ ./common/slp_net.c 2006-11-16 16:19:30.000000000 +0000
@@ -80,7 +80,19 @@ int SLPNetGetThisHostname(char** hostfdn
if(gethostname(host, MAX_HOST_NAME) == 0)
{
- he = gethostbyname(host);
+ if (*host >= '0' && *host <= '9' && inet_aton(host, &ifaddr))
+ {
+ if (numeric_only)
+ {
+ *hostfdn = xstrdup(inet_ntoa(ifaddr));
+ return 0;
+ }
+ he = gethostbyaddr((char *)&ifaddr, sizeof(ifaddr), AF_INET);
+ }
+ else
+ {
+ he = gethostbyname(host);
+ }
if(he)
{
/* if the hostname has a '.' then it is probably a qualified
--- ./common/slp_property.c.orig 2002-12-03 21:04:50.000000000 +0000
+++ ./common/slp_property.c 2006-11-16 16:19:30.000000000 +0000
@@ -219,7 +219,7 @@ int SetDefaultValues()
/*=========================================================================*/
-int SLPPropertyReadFile(const char* conffile)
+int SLPPropertyReadFileFP(FILE *fp)
/* Reads and sets properties from the specified configuration file */
/* */
/* conffile (IN) the path of the config file to read. */
@@ -230,7 +230,6 @@ int SLPPropertyReadFile(const char* conf
{
char* line;
char* alloced;
- FILE* fp;
char* namestart;
char* nameend;
char* valuestart;
@@ -240,6 +239,10 @@ int SLPPropertyReadFile(const char* conf
{
return -1;
}
+ if(!fp)
+ {
+ return 0;
+ }
alloced = xmalloc(4096);
if(alloced == 0)
@@ -249,14 +252,7 @@ int SLPPropertyReadFile(const char* conf
return -1;
}
- fp = fopen(conffile,"r");
- if(!fp)
- {
- goto CLEANUP;
- }
-
- /* Set the property that keeps track of conffile */
- SLPPropertySet("net.slp.OpenSLPConfigFile",conffile);
+ rewind(fp);
while(fgets(alloced,4096,fp))
{
@@ -324,13 +320,6 @@ int SLPPropertyReadFile(const char* conf
}
}
-
- CLEANUP:
- if(fp)
- {
- fclose(fp);
- }
-
if(alloced)
{
xfree(alloced);
@@ -340,6 +329,33 @@ int SLPPropertyReadFile(const char* conf
}
/*=========================================================================*/
+int SLPPropertyReadFile(const char* conffile)
+/* Reads and sets properties from the specified configuration file */
+/* */
+/* conffile (IN) the path of the config file to read. */
+/* */
+/* Returns - zero on success. non-zero on error. Properties will be set*/
+/* to default on error. */
+/*=========================================================================*/
+{
+ FILE* fp;
+ int ret;
+
+ fp = fopen(conffile,"r");
+ if (fp)
+ {
+ /* Set the property that keeps track of conffile */
+ SLPPropertySet("net.slp.OpenSLPConfigFile",conffile);
+ }
+ ret = SLPPropertyReadFileFP(fp);
+ if (fp)
+ {
+ fclose(fp);
+ }
+ return ret;
+}
+
+/*=========================================================================*/
int SLPPropertyAsBoolean(const char* property)
/*=========================================================================*/
{
--- ./common/slp_spi.c.orig 2006-11-16 16:19:17.000000000 +0000
+++ ./common/slp_spi.c 2006-11-16 16:19:30.000000000 +0000
@@ -395,6 +395,8 @@ SLPCryptoDSAKey* SLPSpiGetDSAKey(SLPSpiH
}
tmp->key = SLPSpiReadKeyFile(tmp->keyfilename,keytype);
+ if (!tmp->key)
+ return 0;
}
*key = SLPCryptoDSAKeyDup(tmp->key);
@@ -456,4 +458,15 @@ int SLPSpiCanSign(SLPSpiHandle hspi,
spistr) != 0);
}
-
+void SLPSpiFill(SLPSpiHandle hspi)
+{
+ SLPSpiEntry* entry = (SLPSpiEntry*)hspi->cache.head;
+ while(entry)
+ {
+ if(entry->keytype != SLPSPI_KEY_TYPE_PRIVATE || hspi->cacheprivate)
+ {
+ entry->key = SLPSpiReadKeyFile(entry->keyfilename,entry->keytype);
+ }
+ entry = (SLPSpiEntry*)entry->listitem.next;
+ }
+}
--- ./common/slp_spi.h.orig 2002-03-19 23:52:15.000000000 +0000
+++ ./common/slp_spi.h 2006-11-16 16:19:30.000000000 +0000
@@ -172,7 +172,13 @@ int SLPSpiCanSign(SLPSpiHandle hspi,
/* Returns Non-zero if we sign using the specified SPI */
/*=========================================================================*/
-#endif
+/*=========================================================================*/
+void SLPSpiFill(SLPSpiHandle hspi);
+/* Fill up all entries with private/public keys. */
+/* */
+/* Parameters: hspi (IN) handle obtained from call to SLPSpiOpen() */
+/*=========================================================================*/
+#endif
--- ./common/slp_xcast.c.orig 2003-04-04 06:52:07.000000000 +0000
+++ ./common/slp_xcast.c 2006-11-16 16:19:30.000000000 +0000
@@ -72,6 +72,7 @@
#include "slp_xcast.h"
#include "slp_message.h"
+#include "slp_property.h"
/*========================================================================*/
int SLPBroadcastSend(const SLPIfaceInfo* ifaceinfo,
@@ -172,12 +173,15 @@ int SLPMulticastSend(const SLPIfaceInfo*
int flags = 0;
int xferbytes;
struct in_addr saddr;
+ int optarg;
#if defined(MSG_NOSIGNAL)
flags = MSG_NOSIGNAL;
#endif
+ optarg = atoi(SLPPropertyGet("net.slp.multicastTTL"));
+
for (socks->sock_count = 0;
socks->sock_count < ifaceinfo->iface_count;
socks->sock_count++)
@@ -199,6 +203,14 @@ int SLPMulticastSend(const SLPIfaceInfo*
/* error setting socket option */
return -1;
}
+ if(setsockopt(socks->sock[socks->sock_count],
+ IPPROTO_IP,
+ IP_MULTICAST_TTL,
+ &optarg,
+ sizeof(optarg)))
+ {
+ return -1;
+ }
socks->peeraddr[socks->sock_count].sin_family = AF_INET;
socks->peeraddr[socks->sock_count].sin_port = htons(SLP_RESERVED_PORT);
--- ./libslp/Makefile.am.orig 2001-07-11 21:03:59.000000000 +0000
+++ ./libslp/Makefile.am 2006-11-16 16:19:30.000000000 +0000
@@ -23,6 +23,7 @@ libslp_la_SOURCES = libslp_dereg.c \
libslp_delattrs.c \
libslp_findsrvtypes.c \
libslp_knownda.c \
+ libslp_mdns.c \
libslp.h
libslp_la_LIBADD = ../common/libcommonlibslp.la
libslp_la_LDFLAGS = -version-info 1:0:0
--- ./libslp/libslp_findsrvs.c.orig 2003-04-04 06:52:08.000000000 +0000
+++ ./libslp/libslp_findsrvs.c 2006-11-16 16:29:43.000000000 +0000
@@ -54,7 +54,8 @@ SLPBoolean ColateSLPSrvURLCallback(SLPHa
const char* pcSrvURL,
unsigned short sLifetime,
SLPError errCode,
- void *pvCookie)
+ void *pvCookie,
+ struct sockaddr_in *peerinfo)
/*-------------------------------------------------------------------------*/
{
SLPSrvUrlColatedItem* collateditem;
@@ -107,12 +108,13 @@ SLPBoolean ColateSLPSrvURLCallback(SLPHa
if(collateditem == NULL)
{
collateditem = (SLPSrvUrlColatedItem*) xmalloc(sizeof(SLPSrvUrlColatedItem) + \
- strlen(pcSrvURL) + 1);
+ strlen(pcSrvURL) + 1 + sizeof(*peerinfo));
if(collateditem)
{
memset(collateditem,0,sizeof(SLPSrvUrlColatedItem));
collateditem->srvurl = (char*)(collateditem + 1);
strcpy(collateditem->srvurl,pcSrvURL);
+ memcpy(collateditem->srvurl + strlen(pcSrvURL) + 1, (char *)peerinfo, sizeof(*peerinfo));
collateditem->lifetime = sLifetime;
/* Add the new item to the collated list */
@@ -146,6 +148,38 @@ CLEANUP:
return SLP_FALSE;
}
+char * SLPAPI SLPGetPeer(SLPHandle hSLP, const char *pcURL)
+{
+ PSLPHandleInfo handle;
+ SLPSrvUrlColatedItem* collateditem;
+ struct sockaddr_in peer;
+
+ /*------------------------------*/
+ /* check for invalid parameters */
+ /*------------------------------*/
+ if(hSLP == 0 || *(unsigned int*)hSLP != SLP_HANDLE_SIG || pcURL == 0 || pcURL[0] == 0)
+ {
+ return 0;
+ }
+
+ /*-----------------------------------------*/
+ /* cast the SLPHandle into a SLPHandleInfo */
+ /*-----------------------------------------*/
+ handle = (PSLPHandleInfo)hSLP;
+
+ collateditem = (SLPSrvUrlColatedItem*) handle->collatedsrvurls.head;
+ while(collateditem)
+ {
+ if (strcmp(collateditem->srvurl, pcURL) == 0)
+ {
+ memcpy((char *)&peer, collateditem->srvurl + strlen(collateditem->srvurl) + 1, sizeof(peer));
+ return xstrdup(inet_ntoa(peer.sin_addr));
+ }
+ collateditem = (SLPSrvUrlColatedItem*)collateditem->listitem.next;
+ }
+ return 0;
+}
+
/*-------------------------------------------------------------------------*/
SLPBoolean ProcessSrvRplyCallback(SLPError errorcode,
struct sockaddr_in* peerinfo,
@@ -173,7 +207,8 @@ SLPBoolean ProcessSrvRplyCallback(SLPErr
0,
0,
errorcode,
- handle->params.findsrvs.cookie);
+ handle->params.findsrvs.cookie,
+ peerinfo);
}
/*--------------------*/
@@ -215,7 +250,8 @@ SLPBoolean ProcessSrvRplyCallback(SLPErr
urlentry[i].url,
(unsigned short)urlentry[i].lifetime,
SLP_OK,
- handle->params.findsrvs.cookie);
+ handle->params.findsrvs.cookie,
+ peerinfo);
if(result == SLP_FALSE)
{
break;
@@ -242,7 +278,8 @@ SLPBoolean ProcessSrvRplyCallback(SLPErr
replymsg->body.daadvert.url,
SLP_LIFETIME_MAXIMUM,
SLP_OK,
- handle->params.findsrvs.cookie);
+ handle->params.findsrvs.cookie,
+ peerinfo);
}
else if(replymsg->header.functionid == SLP_FUNCT_SAADVERT)
{
@@ -264,7 +301,8 @@ SLPBoolean ProcessSrvRplyCallback(SLPErr
replymsg->body.saadvert.url,
SLP_LIFETIME_MAXIMUM,
SLP_OK,
- handle->params.findsrvs.cookie);
+ handle->params.findsrvs.cookie,
+ peerinfo);
}
}
--- ./libslp/libslp_mdns.c.orig 2006-11-16 16:19:30.000000000 +0000
+++ ./libslp/libslp_mdns.c 2006-11-16 16:19:30.000000000 +0000
@@ -0,0 +1,915 @@
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <io.h>
+#include <errno.h>
+#define ETIMEDOUT 110
+#define ENOTCONN 107
+#else
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <fcntl.h>
+#include <errno.h>
+#endif
+#include <stdio.h>
+
+#ifndef UNICAST_NOT_SUPPORTED
+#include "../libslp/slp.h"
+#endif
+
+#include "slp_compare.h"
+#include "slp_xcast.h"
+#include "slp_message.h"
+#include "libslp_mdns.h"
+
+
+/*========================================================================*/
+SLPBuffer SLPBufToMDNS(char* buf, int bufsize, int buftype)
+/* Description:
+ * Convert the data part of a SLP request to a MDNS request
+ *========================================================================*/
+{
+ char *srvtype;
+ int srvtypelen;
+ char *scopelist;
+ int scopelistlen;
+ unsigned char *bp, *end;
+ SLPBuffer mdnsbuf;
+ unsigned char txtbuf[512];
+ int txtlen;
+ char *na;
+ int nalen;
+ char *pred;
+ int predlen;
+ char *slpurl;
+ int slpurllen;
+ char *taglist;
+ int taglistlen;
+
+ bp = (unsigned char *)buf;
+ txtlen = 0;
+
+ if (buftype == SLP_FUNCT_SRVTYPERQST)
+ {
+ nalen = AsUINT16(bp);
+ bp += 2;
+ na = bp;
+ if (nalen != 65535)
+ bp += nalen;
+ scopelistlen = AsUINT16(bp);
+ scopelist = bp + 2;
+ if (!SLPContainsStringList(scopelistlen, scopelist, 5, "_mdns"))
+ return 0;
+ bp += 2 + scopelistlen;
+ if (!(mdnsbuf = SLPBufferAlloc(8000)))
+ return 0;
+ bp = mdnsbuf->start;
+ bp[0] = bp[1] = 0; /* ID */
+ bp[2] = 0x01; /* normal query */
+ bp[3] = 0x00;
+ bp[4] = 0x00; /* qcount = 1 */
+ bp[5] = 0x01;
+ bp[6] = bp[7] = 0; /* acount = 0 */
+ bp[8] = bp[9] = 0; /* ncount = 0 */
+ bp[10] = bp[11] = 0; /* xcount = 0 */
+ memcpy(bp + 12, "\011_services\007_dns-sd\004_udp\005local\000", 30);
+ bp += 12 + 30;
+ bp[0] = 0;
+ bp[1] = DNS_TYPE_PTR;
+ bp[2] = 0;
+ bp[3] = DNS_CLASS_IN;
+ mdnsbuf->end = bp + 4;
+ if (nalen != 65535)
+ SLPMDNSAddTxt(txtbuf, sizeof(txtbuf), &txtlen, "namingauth=", na, nalen);
+ }
+ else if (buftype == SLP_FUNCT_SRVRQST)
+ {
+ srvtypelen = AsUINT16(bp);
+ srvtype = bp + 2;
+ bp += 2 + srvtypelen;
+ scopelistlen = AsUINT16(bp);
+ scopelist = bp + 2;
+ bp += 2 + scopelistlen;
+ if (!SLPContainsStringList(scopelistlen, scopelist, 5, "_mdns"))
+ return 0;
+ predlen = AsUINT16(bp);
+ pred = bp + 2;
+ bp += 2 + predlen;
+ if (bp[0] || bp[1]) /* slpspilen */
+ return 0;
+ mdnsbuf = SLPBufferAlloc(8000);
+ if (!mdnsbuf)
+ return 0;
+ bp = mdnsbuf->start;
+ bp[0] = bp[1] = 0; /* ID */
+ bp[2] = 0x01;
+ bp[3] = 0x00;
+ bp[4] = 0x00;
+ bp[5] = 0x01;
+ bp[6] = bp[7] = 0;
+ bp[8] = bp[9] = 0;
+ bp[10] = bp[11] = 0;
+ end = mdnsbuf->start + mdnsbuf->allocated;
+ if (!(bp = SLPMDNSSrvtypeToN(bp + 12, end, srvtype, srvtypelen)) || bp + 4 > end)
+ {
+ SLPBufferFree(mdnsbuf);
+ return 0;
+ }
+ bp[0] = 0;
+ bp[1] = DNS_TYPE_PTR;
+ bp[2] = 0;
+ bp[3] = DNS_CLASS_IN;
+ mdnsbuf->end = bp + 4;
+ SLPMDNSAddTxt(txtbuf, sizeof(txtbuf), &txtlen, "scope=", scopelist, scopelistlen);
+ if (predlen)
+ SLPMDNSAddTxt(txtbuf, sizeof(txtbuf), &txtlen, "predicate=", pred, predlen);
+ }
+ else if (buftype == SLP_FUNCT_ATTRRQST)
+ {
+ slpurllen = AsUINT16(bp);
+ slpurl = bp + 2;
+ bp += 2 + slpurllen;
+ srvtype = slpurl;
+ for (srvtypelen = 0; srvtypelen < slpurllen; srvtypelen++)
+ if (srvtypelen > 2 && slpurl[srvtypelen] == '/' && slpurl[srvtypelen - 1] == '/' && slpurl[srvtypelen - 2] == ':')
+ break;
+ if (srvtypelen != slpurllen)
+ srvtypelen -= 2;
+ else
+ slpurllen = 0;
+ if (srvtypelen <= 0)
+ return 0;
+ scopelistlen = AsUINT16(bp);
+ scopelist = bp + 2;
+ bp += 2 + scopelistlen;
+ if (!SLPContainsStringList(scopelistlen, scopelist, 5, "_mdns"))
+ return 0;
+ taglistlen = AsUINT16(bp);
+ taglist = bp + 2;
+ bp += 2 + taglistlen;
+ if (bp[0] || bp[1]) /* slpspilen */
+ return 0;
+ mdnsbuf = SLPBufferAlloc(8000);
+ if (!mdnsbuf)
+ return 0;
+ bp = mdnsbuf->start;
+ bp[0] = bp[1] = 0; /* ID */
+ bp[2] = 0x01;
+ bp[3] = 0x00;
+ bp[4] = 0x00;
+ bp[5] = 0x01;
+ bp[6] = bp[7] = 0;
+ bp[8] = bp[9] = 0;
+ bp[10] = bp[11] = 0;
+ end = mdnsbuf->start + mdnsbuf->allocated;
+ if (!(bp = SLPMDNSSrvtypeToN(bp + 12, end, srvtype, srvtypelen)) || bp + 4 > end)
+ {
+ SLPBufferFree(mdnsbuf);
+ return 0;
+ }
+ bp[0] = 0;
+ bp[1] = DNS_TYPE_PTR;
+ bp[2] = 0;
+ bp[3] = DNS_CLASS_IN;
+ mdnsbuf->end = bp + 4;
+ if (slpurllen)
+ SLPMDNSAddTxt(txtbuf, sizeof(txtbuf), &txtlen, "slpurl=", slpurl, slpurllen);
+ if (taglistlen)
+ SLPMDNSAddTxt(txtbuf, sizeof(txtbuf), &txtlen, "taglist=", taglist, taglistlen);
+ }
+ else
+ {
+ return 0;
+ }
+ if (txtlen)
+ {
+ /* small hack: we patch in the compression vector afterwards */
+ bp = SLPMDNSAddRR(mdnsbuf->end, mdnsbuf->start, mdnsbuf->start + mdnsbuf->allocated, "\012_slpqueryX\000", 0, DNS_TYPE_TXT, 0, 0, 0, txtlen, txtbuf, 0);
+ if (bp)
+ {
+ /* set compression pointer to query */
+ mdnsbuf->end[0] = 9;
+ mdnsbuf->end[10] = 0xc0;
+ mdnsbuf->end[11] = 12;
+ mdnsbuf->end = bp;
+ mdnsbuf->start[7]++; /* increment acount */
+ }
+ }
+#ifdef DEBUG
+ SLPMDNSDumpDNS(mdnsbuf, "-> srvtype");
+#endif
+ return mdnsbuf;
+}
+
+static int SLPMDNSCmpRRData(unsigned char *a, unsigned char *ra, unsigned char *b, unsigned char *rb)
+{
+ int type = AsUINT16(a);
+ if (memcmp(a, b, 4))
+ return 1;
+ if (type == DNS_TYPE_PTR)
+ return SLPMDNSCmpN(a + 10, ra, b + 10, rb);
+ if (type == DNS_TYPE_SRV)
+ {
+ if (memcmp(a + 10, b + 10, 6))
+ return 1;
+ return SLPMDNSCmpN(a + 16, ra, b + 16, rb);
+ }
+ return memcmp(a + 8, b + 8, 2 + AsUINT16(a + 8));
+}
+
+int SLPMDNSNToAttrs(unsigned char *txtbuf, int txtlen, char *buf, int len)
+{
+ char *bp = buf;
+ int i, l;
+ int comma = 0;
+
+ while (txtlen)
+ {
+ l = *txtbuf++;
+ txtlen--;
+ if (l > txtlen)
+ return 0;
+ for (i = 0; i < l; i++)
+ if (txtbuf[i] == '=')
+ break;
+ if (comma)
+ {
+ if (len == 0)
+ return 0;
+ *bp++ = ',';
+ len--;
+ }
+ comma = 1;
+ if (i == l)
+ {
+ /* keyword */
+ if (l > len)
+ return 0;
+ memcpy(bp, txtbuf, l);
+ bp += l;
+ len -= l;
+ }
+ else
+ {
+ if (l + 2 > len)
+ return 0;
+ /* (keyword=values) */
+ *bp++ = '(';
+ memcpy(bp, txtbuf, l);
+ bp += l;
+ *bp++ = ')';
+ len -= l + 2;
+ }
+ txtbuf += l;
+ txtlen -= l;
+ }
+ return bp - buf;
+}
+
+
+/*========================================================================*/
+int SLPMDNSToBuf(SLPBuffer buf, struct sockaddr *peer, int peerlen, SLPBuffer mdnssendbuf, int buftype, PSLPHandleInfo handle)
+/* Description:
+ * Convert the an MDNS answer to a SLP answer
+ *========================================================================*/
+{
+ int qcount, acount, ncount, xcount;
+ unsigned char *end = buf->end;
+ unsigned char *bp, *obp;
+ unsigned char slpbuf[8000], *slpbufend;
+ unsigned char *an[SLP_MDNS_MAX_RR];
+ unsigned char *ad[SLP_MDNS_MAX_RR];
+ unsigned char *xn[SLP_MDNS_MAX_RR];
+ unsigned char *xd[SLP_MDNS_MAX_RR];
+ int ac, xc, i, j, rac, l, type;
+ int jsrv, ja, jtxt;
+ unsigned char *cvec[256];
+ unsigned char *ran[SLP_MDNS_MAX_RR];
+ unsigned char *rad[SLP_MDNS_MAX_RR];
+ int ncvec;
+ unsigned char *slpurl;
+ unsigned int ttl;
+ unsigned char *name;
+ int namelen;
+ int urllen;
+
+ if (end - buf->start < 12)
+ return 1; /* too small */
+#ifdef DEBUG
+ SLPMDNSDumpDNS(buf, "<-");
+#endif
+ if (buf->start[0] != mdnssendbuf->start[0])
+ return 1; /* XID mismatch */
+ if (buf->start[1] != mdnssendbuf->start[1])
+ return 1; /* XID mismatch */
+ if ((buf->start[2] & 0xf0) != 0x80)
+ return 1; /* no standard response */
+ if ((buf->start[3] & 0x0f) != 0x00)
+ return 1; /* DNS error */
+ qcount = AsUINT16(buf->start + 4);
+ if (qcount > 1)
+ return 1; /* we didn't query this */
+
+ slpbuf[0] = 2;
+ if (buftype == SLP_FUNCT_SRVTYPERQST)
+ slpbuf[1] = SLP_FUNCT_SRVTYPERPLY;
+ else if (buftype == SLP_FUNCT_SRVRQST)
+ slpbuf[1] = SLP_FUNCT_SRVRPLY;
+ else if (buftype == SLP_FUNCT_ATTRRQST)
+ slpbuf[1] = SLP_FUNCT_ATTRRPLY;
+ else
+ return 1; /* internal error */
+ slpbuf[2] = slpbuf[3] = slpbuf[4] = 0; /* length */
+ slpbuf[5] = slpbuf[6] = 0; /* flags */
+ slpbuf[7] = slpbuf[8] = slpbuf[9] = 0; /* ext off */
+ slpbuf[10] = mdnssendbuf->start[0]; /* xid */
+ slpbuf[11] = mdnssendbuf->start[1]; /* xid */
+ slpbuf[12] = slpbuf[13] = 0; /* ltaglen */
+ slpbuf[14] = slpbuf[15] = 0; /* error code */
+ slpbuf[16] = slpbuf[17] = 0; /* url count */
+ slpurl = slpbuf + 18;
+
+ acount = AsUINT16(buf->start + 6);
+ ncount = AsUINT16(buf->start + 8);
+ xcount = AsUINT16(buf->start + 10);
+
+ /* set up compression vector from old query */
+ cvec[0] = bp = mdnssendbuf->start + 12;
+ ncvec = 1;
+ while (bp < end && *bp)
+ bp += *bp + 1;
+ bp += 1 + 4;
+ bp = SLPMDNSParseRR(bp, mdnssendbuf->end, AsUINT16(mdnssendbuf->start + 6), ran, rad, &rac);
+ for (i = 0; i < rac; i++)
+ {
+ if ((ran[i][0] & 0xc0) == 0xc0 && ncvec < 256)
+ cvec[ncvec++] = ran[i];
+ if (AsUINT16(rad[i]) == DNS_TYPE_PTR)
+ {
+ if ((rad[i][10] & 0xc0) == 0xc0 && ncvec < 256)
+ cvec[ncvec++] = rad[i] + 10;
+ }
+ }
+
+ bp = buf->start + 12;
+ /* skip query section */
+ if (qcount)
+ {
+ while (bp < end && *bp && (*bp & 0xc0) != 0xc0)
+ bp += *bp + 1;
+ if (bp < end && *bp)
+ bp++;
+ bp += 5;
+ }
+ bp = SLPMDNSParseRR(bp, end, acount, an, ad, &ac);
+ if (bp > end)
+ return 1;
+ bp = SLPMDNSParseRR(bp, end, ncount, 0, 0, 0);
+ bp = SLPMDNSParseRR(bp, end, xcount, xn, xd, &xc);
+
+ /* now that we know the end of the packet validate rrs */
+ SLPMDNSCheckRR(buf->start, bp > end ? end : bp, an, ad, &ac);
+ SLPMDNSCheckRR(buf->start, bp > end ? end : bp, xn, xd, &xc);
+ /* printf("checked rrs: ac=%d, xc=%d\n", ac, xc); */
+
+ /* add answer rrs to our query if not already there */
+ for (i = 0; i < ac; i++)
+ {
+ /* is this an answer we are looking for? */
+ if (SLPMDNSCmpN(an[i], buf->start,
+ mdnssendbuf->start + 12, mdnssendbuf->start))
+ continue;
+ type = AsUINT16(ad[i]);
+ /* skip everything but PTR RR, CLASS INs */
+ if (type != DNS_TYPE_PTR)
+ continue;
+ if (AsUINT16(ad[i] + 2) != DNS_CLASS_IN)
+ continue;
+
+ for (j = 0; j < rac; j++)
+ if (!SLPMDNSCmpRRData(ad[i], buf->start, rad[j], mdnssendbuf->start))
+ break;
+ if (j < rac)
+ continue;
+ /* new rr, add it to query */
+ if (rac < SLP_MDNS_MAX_RR)
+ {
+ bp = mdnssendbuf->end;
+ ran[rac] = bp;
+ bp = SLPMDNSAddRR(bp, mdnssendbuf->start, mdnssendbuf->start + mdnssendbuf->allocated, an[i], buf->start, type, AsUINT32(ad[i] + 4), cvec, &ncvec, 0, ad[i] + 10, rad + rac);
+ if (bp)
+ {
+ mdnssendbuf->end = bp;
+ j = AsUINT16(mdnssendbuf->start + 6);
+ ToUINT16(mdnssendbuf->start + 6, j + 1);
+ rac++;
+ }
+ }
+#ifdef DEBUG
+ SLPMDNSDumpDNS(mdnssendbuf, "updated sendbuf");
+#endif
+
+ slpbufend = slpbuf + sizeof(slpbuf);
+ if (buftype == SLP_FUNCT_SRVTYPERQST)
+ {
+ int comma = slpbuf[16] || slpbuf[17] ? 1 : 0;
+ l = SLPMDNSNToSrvtype(ad[i] + 10, buf->start, slpurl + comma, slpbufend - (slpurl + comma));
+ if (!l)
+ continue;
+ if (comma)
+ *slpurl++ = ',';
+ slpurl += l;
+ ToUINT16(slpbuf + 16, slpurl - (slpbuf + 18));
+ continue;
+ }
+ if (buftype == SLP_FUNCT_ATTRRQST)
+ {
+ unsigned char *txtbuf;
+ int txtlen;
+
+ int comma = slpbuf[16] || slpbuf[17] ? 1 : 0;
+ /* find TXT record in additional section */
+ for (jtxt = 0; jtxt < xcount; jtxt++)
+ if (AsUINT16(xd[jtxt]) == DNS_TYPE_TXT
+ && !SLPMDNSCmpN(ad[i] + 10, buf->start, xn[jtxt], buf->start))
+ break;
+ if (jtxt == xcount)
+ continue; /* oops, no TXT */
+ txtbuf = xd[jtxt] + 10;
+ txtlen = AsUINT16(xd[jtxt] + 8);
+ /* skip internal slpurl attribute */
+ if (txtlen > 7 && *txtbuf > 7 && *txtbuf + 1 <= txtlen && !strncasecmp(txtbuf + 1, "slpurl=", 7)) {
+ txtlen -= *txtbuf + 1;
+ txtbuf += *txtbuf + 1;
+ }
+ /* extra +1 for # of AttrAuths added later */
+ l = SLPMDNSNToAttrs(txtbuf, txtlen, slpurl + comma, slpbufend - (slpurl + comma + 1));
+ if (!l)
+ continue;
+ if (comma)
+ *slpurl++ = ',';
+ slpurl += l;
+ ToUINT16(slpbuf + 16, slpurl - (slpbuf + 18));
+ continue;
+ }
+
+ /* now create a nice url */
+ /* find SRV record in the additional section */
+ for (jsrv = 0; jsrv < xcount; jsrv++)
+ if (AsUINT16(xd[jsrv]) == DNS_TYPE_SRV
+ && !SLPMDNSCmpN(ad[i] + 10, buf->start, xn[jsrv], buf->start))
+ break;
+ if (jsrv == xcount)
+ continue; /* oops, server didn't send SRV RR */
+ for (ja = 0; ja < xcount; ja++)
+ if (AsUINT16(xd[ja]) == DNS_TYPE_A
+ && !SLPMDNSCmpN(xd[jsrv] + 10 + 6, buf->start, xn[ja], buf->start))
+ break;
+ if (ja == xcount)
+ ja = -1;
+ for (jtxt = 0; jtxt < xcount; jtxt++)
+ if (AsUINT16(xd[jtxt]) == DNS_TYPE_TXT
+ && !SLPMDNSCmpN(ad[i] + 10, buf->start, xn[jtxt], buf->start))
+ break;
+ if (jtxt == xcount)
+ jtxt = -1;
+
+ /* calculate slp TTL */
+ ttl = AsUINT32(xd[jsrv] + 4);
+ if (ttl > 65535)
+ ttl = 65535;
+
+ /* check if we hava an "slpurl" attribute in the TXT entry */
+ if (jtxt >= 0)
+ {
+ char *txt;
+ l = 0;
+ txt = SLPMDNSFindInTxt(xd[jtxt] + 10, AsUINT16(xd[jtxt] + 8), "slpurl=", &l);
+ if (txt && l)
+ {
+ /* found it, great! add the slpurl */
+ if (slpurl + 6 + l >= slpbufend)
+ continue;
+ *slpurl = 0; /* reserved */
+ ToUINT16(slpurl + 1, ttl);
+ ToUINT16(slpurl + 3, l);
+ memcpy(slpurl + 5, txt, l);
+ slpurl[5 + l] = 0; /* url auths */
+ slpurl += 6 + l;
+ if (++slpbuf[17] == 0)
+ slpbuf[16]++;
+ continue;
+ }
+ }
+
+ bp = mdnssendbuf->start + 12; /* equal to an[i], not compr. */
+ l = *bp++;
+ if (*bp == '_')
+ {
+ l--;
+ bp++;
+ }
+ if (l == 0 || l >= 64 || slpurl + 16 + l >= slpbufend)
+ continue;
+ memcpy(slpurl, "\0\0\0\0\0service:", 13);
+ ToUINT16(slpurl + 1, ttl);
+ memcpy(slpurl + 13, bp, l);
+ bp = slpurl + 13;
+ /* convert : to . */
+ for (; *bp && l-- > 0; bp++)
+ if (*bp == ':')
+ *bp = '.';
+ *bp++ = ':';
+ *bp++ = '/';
+ *bp++ = '/';
+ obp = bp;
+ bp = SLPMDNSNToStr(bp, slpbufend - 1 - 8, xd[jsrv] + 10 + 6, buf->start, 1);
+ if (bp == 0)
+ continue;
+ if (ja >= 0 && (xd[ja][10] != 169 || xd[ja][11] != 254) && bp - obp > 6 && !strncmp(bp - 6, ".local", 6))
+ {
+ /* got .local address but ip isn't local. Lookup. */
+ struct sockaddr_in sai;
+ sai.sin_family = AF_INET;
+ memcpy(&sai.sin_addr.s_addr, xd[ja] + 10, 4);
+ if (getnameinfo((struct sockaddr *)&sai, sizeof(sai),
+ obp, slpbufend - 1 - 8 - obp,
+ (char *)0, 0, NI_NAMEREQD) == 0
+ && obp + strlen(obp) < slpbufend - 1 - 9)
+ {
+ bp = obp + strlen(obp);
+ }
+ else
+ {
+ /* recreate old content */
+ bp = SLPMDNSNToStr(obp, slpbufend - 1 - 8, xd[jsrv] + 10 + 6, buf->start, 1);
+ }
+ }
+ sprintf(bp, ":%u", AsUINT16(xd[jsrv] + 14));
+ bp += strlen(bp);
+ urllen = bp - (slpurl + 5);
+ ToUINT16(slpurl + 3, urllen);
+ *bp++ = 0; /* 0 url blocks */
+
+ /* add extra name info */
+ name = ad[i] + 10;
+ if ((*name & 0xc0) == 0xc0)
+ name = buf->start + ((*name & 0x3f) << 8 | name[1]);
+ namelen = *name++;
+ if (namelen && urllen && buftype == SLP_FUNCT_SRVRQST)
+ {
+ SLPSrvUrlColatedItem *collateditem;
+ collateditem = (SLPSrvUrlColatedItem*) xmalloc(sizeof(SLPSrvUrlColatedItem) + 3 + urllen + namelen);
+ if (collateditem)
+ {
+ memset(collateditem,0,sizeof(SLPSrvUrlColatedItem));
+ collateditem->srvurl = (char*)(collateditem + 1);
+ collateditem->srvurl[0] = 0;
+ strcpy(collateditem->srvurl + 1, slpurl + 5);
+ memcpy(collateditem->srvurl + 1 + urllen + 1, name, namelen);
+ collateditem->srvurl[2 + urllen + namelen] = 0;
+ SLPListLinkTail(&(handle->collatedsrvurls), (SLPListItem*)collateditem);
+ }
+ }
+
+ /* sucessfully added url */
+ slpurl = bp;
+ if (++slpbuf[17] == 0)
+ slpbuf[16]++;
+ }
+ if ((!slpbuf[16] && !slpbuf[17]) || slpurl - slpbuf > buf->allocated)
+ return 1;
+ if (buftype == SLP_FUNCT_ATTRRQST)
+ {
+ /* we already know there is room for this byte */
+ *slpurl++ = 0;
+ }
+ ToUINT24(slpbuf + 2, slpurl - slpbuf);
+ memcpy(buf->start, slpbuf, slpurl - slpbuf);
+#ifdef DEBUG
+ printf("SLP buffer\n");
+ SLPMDNSDumpBuf(slpbuf, slpurl - slpbuf);
+#endif
+ buf->end = buf->start + (slpurl - slpbuf);
+ buf->curpos = buf->start;
+ return 0;
+}
+
+const char *SLPAPI SLPGetMDNSName(SLPHandle hSLP, const char *pcURL)
+{
+
+ PSLPHandleInfo handle;
+ SLPSrvUrlColatedItem* collateditem;
+
+ /*------------------------------*/
+ /* check for invalid parameters */
+ /*------------------------------*/
+ if(hSLP == 0 || *(unsigned int*)hSLP != SLP_HANDLE_SIG || pcURL == 0)
+ {
+ return 0;
+ }
+
+ /*-----------------------------------------*/
+ /* cast the SLPHandle into a SLPHandleInfo */
+ /*-----------------------------------------*/
+ handle = (PSLPHandleInfo)hSLP;
+
+ collateditem = (SLPSrvUrlColatedItem*) handle->collatedsrvurls.head;
+ while(collateditem)
+ {
+ if (collateditem->srvurl[0] == 0
+ && strcmp(collateditem->srvurl + 1,pcURL) == 0)
+ return collateditem->srvurl + strlen(collateditem->srvurl + 1) + 2;
+ collateditem = (SLPSrvUrlColatedItem*)collateditem->listitem.next;
+ }
+ return 0;
+}
+
+
+/*========================================================================*/
+int SLPMDNSMulticastSend(const SLPIfaceInfo* ifaceinfo,
+ SLPBuffer msg,
+ SLPXcastSockets* socks)
+/* Description:
+ * Multicast a message.
+ *
+ * Parameters:
+ * ifaceinfo (IN) Pointer to the SLPIfaceInfo structure that contains
+ * information about the interfaces to send on
+ * msg (IN) Buffer to send
+ *
+ * socks (OUT) Sockets used to multicast. May be used to recv()
+ * responses. MUST be close by caller using
+ * SLPXcastSocketsClose()
+ *
+ * Returns:
+ * Zero on sucess. Non-zero with errno set on error
+ *========================================================================*/
+{
+ int flags = 0;
+ int on = 1;
+ int xferbytes;
+ struct in_addr saddr;
+
+#if defined(MSG_NOSIGNAL)
+ flags = MSG_NOSIGNAL;
+#endif
+
+ for (socks->sock_count = 0;
+ socks->sock_count < ifaceinfo->iface_count;
+ socks->sock_count++)
+ {
+ socks->sock[socks->sock_count] = socket(AF_INET, SOCK_DGRAM, 0);
+ if (socks->sock[socks->sock_count] < 0)
+ {
+ /* error creating socket */
+ return -1;
+ }
+ if (setsockopt(socks->sock[socks->sock_count],
+ SOL_IP,
+ IP_RECVTTL,
+ &on,
+ sizeof(on))) {
+ /* error setting socket option */
+ return -1;
+ }
+
+ saddr.s_addr = ifaceinfo->iface_addr[socks->sock_count].sin_addr.s_addr;
+ if( setsockopt(socks->sock[socks->sock_count],
+ IPPROTO_IP,
+ IP_MULTICAST_IF,
+ (char*)&saddr,
+ sizeof(struct in_addr)))
+ {
+ /* error setting socket option */
+ return -1;
+ }
+
+ socks->peeraddr[socks->sock_count].sin_family = AF_INET;
+ socks->peeraddr[socks->sock_count].sin_port = htons(MDNS_RESERVED_PORT);
+ socks->peeraddr[socks->sock_count].sin_addr.s_addr = htonl(MDNS_MCAST_ADDRESS);
+
+ xferbytes = sendto(socks->sock[socks->sock_count],
+ msg->start,
+ msg->end - msg->start,
+ flags,
+ (struct sockaddr *) &(socks->peeraddr[socks->sock_count]),
+ sizeof(struct sockaddr_in));
+ if (xferbytes <= 0)
+ {
+ /* error sending */
+ return -1;
+ }
+ }
+ return 0;
+}
+
+
+/*=========================================================================*/
+int SLPMDNSXcastRecvMessage(const SLPXcastSockets* sockets,
+ const SLPXcastSockets* mdnssockets,
+ SLPBuffer *buf,
+ struct sockaddr_in* peeraddr,
+ struct timeval* timeout,
+ SLPBuffer mdnssendbuf, int buftype,
+ PSLPHandleInfo handle)
+/* Description:
+ * Receives datagram messages from one of the sockets in the specified <20>
+ * SLPXcastsSockets structure
+ *
+ * Parameters:
+ * sockets (IN) Pointer to the SOPXcastSockets structure that describes
+ * which sockets to read slp messages from.
+ * sockets (IN) Pointer to the SOPXcastSockets structure that describes
+ * which sockets to read mdns messages from.
+ * buf (OUT) Pointer to SLPBuffer that will contain the message upon
+ * successful return.
+ * peeraddr (OUT) Pointer to struc sockaddr_in that will contain the
+ * address of the peer that sent the received message.
+ * timeout (IN/OUT) pointer to the struct timeval that indicates how much
+ * time to wait for a message to arrive
+ * mdnssendbuf (IN/OUT) Pointer to SLPBuffer that contains the MDNS message.
+ * We will add our received RRs here (known answer
+ * suppression)
+ *
+ * Returns:
+ * Zero on success, non-zero with errno set on failure.
+ *========================================================================*/
+{
+ fd_set readfds;
+ int highfd;
+ int i;
+ int readable;
+ size_t bytesread;
+ int recvloop;
+ int peeraddrlen = sizeof(struct sockaddr_in);
+ char peek[16];
+ int result = 0;
+ struct msghdr mhdr;
+ struct iovec iov;
+ unsigned char cmsgbuf[CMSG_SPACE(sizeof(int))];
+ struct cmsghdr *cmsg;
+ int ttl;
+
+ /* recv loop */
+ recvloop = 1;
+ while(recvloop)
+ {
+ /* Set the readfds */
+ FD_ZERO(&readfds);
+ highfd = 0;
+ for (i=0; i<sockets->sock_count; i++)
+ {
+ FD_SET(sockets->sock[i],&readfds);
+ if(sockets->sock[i] > highfd)
+ highfd = sockets->sock[i];
+ }
+ for (i=0; i<mdnssockets->sock_count; i++)
+ {
+ FD_SET(mdnssockets->sock[i],&readfds);
+ if(mdnssockets->sock[i] > highfd)
+ highfd = mdnssockets->sock[i];
+ }
+
+ /* Select */
+ readable = select(highfd + 1,&readfds,NULL,NULL,timeout);
+ if(readable > 0)
+ {
+ /* Read the datagram */
+ for (i=0; i<sockets->sock_count; i++)
+ {
+ if(FD_ISSET(sockets->sock[i],&readfds))
+ {
+ /* Peek at the first 16 bytes of the header */
+ bytesread = recvfrom(sockets->sock[i],
+ peek,
+ 16,
+ MSG_PEEK,
+ (struct sockaddr *)peeraddr,
+ &peeraddrlen);
+ if(bytesread == 16
+#ifdef _WIN32
+ /* Win32 returns WSAEMSGSIZE if the message is larger than
+ * the requested size, even with MSG_PEEK. But if this is the
+ * error code we can be sure that the message is at least 16
+ * bytes */
+ || (bytesread == (size_t)-1 && WSAGetLastError() == WSAEMSGSIZE)
+#endif
+ )
+ {
+ if(AsUINT24(peek + 2) <= SLP_MAX_DATAGRAM_SIZE)
+ {
+ *buf = SLPBufferRealloc(*buf, AsUINT24(peek + 2));
+ bytesread = recv(sockets->sock[i],
+ (*buf)->curpos,
+ (*buf)->end - (*buf)->curpos,
+ 0);
+ if(bytesread != AsUINT24(peek + 2))
+ {
+ /* This should never happen but we'll be paranoid*/
+ (*buf)->end = (*buf)->curpos + bytesread;
+ }
+
+ /* Message read. We're done! */
+ result = 0;
+ recvloop = 0;
+ break;
+ }
+ else
+ {
+ /* we got a bad message, or one that is too big! */
+#ifndef UNICAST_NOT_SUPPORTED
+ /* Reading SLP_MAX_DATAGRAM_SIZE bytes on the socket */
+ *buf = SLPBufferRealloc(*buf, SLP_MAX_DATAGRAM_SIZE);
+ bytesread = recv(sockets->sock[i],
+ (*buf)->curpos,
+ (*buf)->end - (*buf)->curpos,
+ 0);
+ if(bytesread != SLP_MAX_DATAGRAM_SIZE)
+ {
+ /* This should never happen but we'll be paranoid*/
+ (*buf)->end = (*buf)->curpos + bytesread;
+ }
+ result = SLP_RETRY_UNICAST;
+ recvloop = 0;
+ return result;
+#endif
+ }
+ }
+ else
+ {
+ /* Not even 16 bytes available */
+ }
+ }
+ }
+ for (i=0; i<mdnssockets->sock_count; i++)
+ {
+ if(!FD_ISSET(mdnssockets->sock[i],&readfds))
+ continue;
+ *buf = SLPBufferRealloc(*buf, 8000);
+ (*buf)->curpos = (*buf)->start;
+#if 1
+ iov.iov_base = (*buf)->curpos;
+ iov.iov_len = (*buf)->end - (*buf)->curpos;
+ mhdr.msg_name = (struct sockaddr *)peeraddr;
+ mhdr.msg_namelen = peeraddrlen;
+ mhdr.msg_iov = &iov;
+ mhdr.msg_iovlen = 1;
+ mhdr.msg_control = cmsgbuf;
+ mhdr.msg_controllen = sizeof(cmsgbuf);
+ mhdr.msg_flags = 0;
+ bytesread = recvmsg(mdnssockets->sock[i], &mhdr, 0);
+ if (bytesread < 12)
+ continue;
+ cmsg = CMSG_FIRSTHDR(&mhdr);
+ for (cmsg = CMSG_FIRSTHDR(&mhdr); cmsg; CMSG_NXTHDR(&mhdr, cmsg))
+ if (cmsg->cmsg_level == SOL_IP && cmsg->cmsg_type == IP_TTL)
+ break;
+ if (!cmsg)
+ continue;
+ ttl = *(int *)CMSG_DATA(cmsg);
+ if (ttl != 255)
+ {
+ continue;
+ }
+#else
+ bytesread = recvfrom(mdnssockets->sock[i],
+ (*buf)->curpos,
+ (*buf)->end - (*buf)->curpos,
+ 0,
+ (struct sockaddr *)peeraddr,
+ &peeraddrlen);
+ if (bytesread < 12)
+ continue;
+#endif
+ (*buf)->end = (*buf)->start + bytesread;
+ if (SLPMDNSToBuf(*buf, (struct sockaddr *)peeraddr, peeraddrlen, mdnssendbuf, buftype, handle) == 0)
+ {
+ result = 0;
+ recvloop = 0;
+ break;
+ }
+ }
+ }
+ else if(readable == 0)
+ {
+ result = -1;
+ errno = ETIMEDOUT;
+ recvloop = 0;
+ }
+ else
+ {
+ result = -1;
+ recvloop = 0;
+ }
+ }
+
+ return result;
+}
+
--- ./libslp/libslp_mdns.h.orig 2006-11-16 16:19:30.000000000 +0000
+++ ./libslp/libslp_mdns.h 2006-11-16 16:19:30.000000000 +0000
@@ -0,0 +1,14 @@
+#include "slp_mdns.h"
+#include "libslp.h"
+
+extern SLPBuffer SLPBufToMDNS(char* buf, int bufsize, int buftype);
+extern int SLPMDNSToBuf(SLPBuffer buf, struct sockaddr *peer,
+ int peerlen, SLPBuffer mdnssendbuf, int buftype, PSLPHandleInfo handle);
+extern int SLPMDNSMulticastSend(const SLPIfaceInfo* ifaceinfo,
+ SLPBuffer msg, SLPXcastSockets* socks);
+extern int SLPMDNSXcastRecvMessage(const SLPXcastSockets* sockets,
+ const SLPXcastSockets* mdnssockets,
+ SLPBuffer *buf,
+ struct sockaddr_in* peeraddr,
+ struct timeval* timeout,
+ SLPBuffer mdnssendbuf, int buftype, PSLPHandleInfo handle);
--- ./libslp/libslp_network.c.orig 2003-08-20 05:25:58.000000000 +0000
+++ ./libslp/libslp_network.c 2006-11-16 16:19:30.000000000 +0000
@@ -49,6 +49,7 @@
#include "slp.h"
#include "libslp.h"
+#include "libslp_mdns.h"
/*=========================================================================*/
@@ -660,6 +661,15 @@ SLPError NetworkMcastRqstRply(const char
SLPIfaceInfo ifaceinfo;
SLPXcastSockets xcastsocks;
+ int usemdns = 1;
+ int useslp = 1;
+ SLPBuffer mdnssendbuf = 0;
+ SLPXcastSockets mdnsxcastsocks;
+
+ /* initialize sock_count so that CLEANUP won't get hurt */
+ xcastsocks.sock_count = 0;
+ mdnsxcastsocks.sock_count = 0;
+
#ifdef DEBUG
/* This function only supports multicast or broadcast of the following
* messages
@@ -726,6 +736,7 @@ SLPError NetworkMcastRqstRply(const char
/* SLP_FUNCT_DASRVRQST is a fake function. We really want to */
/* send a SRVRQST */
buftype = SLP_FUNCT_SRVRQST;
+ usemdns = 0;
}
/*---------------------------------------------------------------------*/
@@ -744,6 +755,13 @@ SLPError NetworkMcastRqstRply(const char
*prlist = 0;
prlistlen = 0;
+ if (usemdns)
+ {
+ mdnssendbuf = SLPBufToMDNS(buf, bufsize, buftype);
+ if (!mdnssendbuf)
+ usemdns = 0;
+ }
+
/*--------------------------*/
/* Main retransmission loop */
/*--------------------------*/
@@ -831,14 +849,23 @@ SLPError NetworkMcastRqstRply(const char
/*----------------------*/
/* send the send buffer */
/*----------------------*/
- if(usebroadcast)
- {
- result = SLPBroadcastSend(&ifaceinfo,sendbuf,&xcastsocks);
- }
- else
- {
- result = SLPMulticastSend(&ifaceinfo,sendbuf,&xcastsocks);
- }
+ result = 0;
+ if (useslp)
+ {
+ if(usebroadcast)
+ {
+ result = SLPBroadcastSend(&ifaceinfo,sendbuf,&xcastsocks);
+ }
+ else
+ {
+ result = SLPMulticastSend(&ifaceinfo,sendbuf,&xcastsocks);
+ }
+ }
+ if (result == 0 && usemdns)
+ {
+ ToUINT16(mdnssendbuf->start,xid);
+ result = SLPMDNSMulticastSend(&ifaceinfo,mdnssendbuf,&mdnsxcastsocks);
+ }
if(result != 0)
{
/* we could not send the message for some reason */
@@ -851,20 +878,19 @@ SLPError NetworkMcastRqstRply(const char
/*----------------*/
while(1)
{
- #ifndef UNICAST_NOT_SUPPORTED
- int retval = 0;
- if((retval = SLPXcastRecvMessage(&xcastsocks,
- &recvbuf,
- &peeraddr,
- &timeout)) != 0)
- #else
-
- if(SLPXcastRecvMessage(&xcastsocks,
- &recvbuf,
- &peeraddr,
- &timeout) != 0)
- #endif
-
+ int retval;
+ if (usemdns)
+ retval = SLPMDNSXcastRecvMessage(&xcastsocks,
+ &mdnsxcastsocks,
+ &recvbuf,
+ &peeraddr,
+ &timeout, mdnssendbuf, buftype, handle);
+ else
+ retval = SLPXcastRecvMessage(&xcastsocks,
+ &recvbuf,
+ &peeraddr,
+ &timeout);
+ if (retval != 0)
{
/* An error occured while receiving the message */
/* probably a just time out error. break for re-send. */
@@ -972,13 +998,16 @@ SLPError NetworkMcastRqstRply(const char
goto CLEANUP;
}
- /* add the peer to the previous responder list */
- if(prlistlen != 0)
- {
- strcat(prlist,",");
- }
- strcat(prlist,inet_ntoa(peeraddr.sin_addr));
- prlistlen = strlen(prlist);
+ if (prlistlen + 14 < mtu)
+ {
+ /* add the peer to the previous responder list */
+ if(prlistlen != 0)
+ {
+ strcat(prlist,",");
+ }
+ strcat(prlist,inet_ntoa(peeraddr.sin_addr));
+ prlistlen = strlen(prlist);
+ }
}
}
@@ -1016,8 +1045,11 @@ SLPError NetworkMcastRqstRply(const char
/*----------------*/
if(prlist) xfree(prlist);
SLPBufferFree(sendbuf);
+ SLPBufferFree(mdnssendbuf);
SLPBufferFree(recvbuf);
SLPXcastSocketsClose(&xcastsocks);
+ if (usemdns)
+ SLPXcastSocketsClose(&mdnsxcastsocks);
return result;
}
@@ -1190,6 +1222,7 @@ SLPError NetworkUcastRqstRply(PSLPHandle
/* send the send buffer */
/*----------------------*/
+ peeraddr = handle->unicastaddr;
handle->unicastsock = SLPNetworkConnectStream(&(handle->unicastaddr), &timeout);
if ( handle->unicastsock >= 0 ) {
retval1 = SLPNetworkSendMessage(handle->unicastsock, SOCK_STREAM, sendbuf, &(handle->unicastaddr), &timeout);
--- ./libslp/slp.h.orig 2003-04-21 11:26:54.000000000 +0000
+++ ./libslp/slp.h 2006-11-16 16:42:16.000000000 +0000
@@ -981,6 +981,41 @@ SLPEXP SLPError SLPAPI SLPParseAttrs(con
/* was not found otherwise SLP_OK */
/*=========================================================================*/
+
+/*=========================================================================*/
+SLPEXP const char* SLPAPI SLPGetMDNSName(SLPHandle hSLP,
+ const char *pcURL);
+/* */
+/* Used to get the MDNS name corresponding to a service URL. This function */
+/* may only be called from a SLPSrvURLCallback. */
+/* */
+/* hSLP The language specific SLPHandle on which to search for */
+/* the MDNS name. */
+/* */
+/* pcURL (IN) The service URL. */
+/* */
+/* Returns: Returns NULL if no name is available for the URL, otherwise */
+/* the name. Note that the memory belongs to libslp and must not */
+/* be freed! */
+/*=========================================================================*/
+
+
+/*=========================================================================*/
+SLPEXP char * SLPAPI SLPGetPeer(SLPHandle hSLP,
+ const char *pcURL);
+/* */
+/* Used to get the peer info corresponding to a service URL. This function */
+/* may only be called from a SLPSrvURLCallback. */
+/* The memory should be freed by calling SLPFree(). */
+/* */
+/* hSLP The language specific SLPHandle on which to search for */
+/* the MDNS name. */
+/* */
+/* pcURL (IN) The service URL. */
+/* */
+/* Returns: the ip address if the peer, NULL if not available */
+/*=========================================================================*/
+
#if(defined __cplusplus)
}
#endif
--- ./libslpattr/libslpattr.c.orig 2002-11-23 03:44:53.000000000 +0000
+++ ./libslpattr/libslpattr.c 2006-11-16 16:19:30.000000000 +0000
@@ -360,6 +360,11 @@ int find_value_list_end(char const *valu
(*cur)++;
}
+ if (type_guess == TYPE_UNKNOWN)
+ {
+ return 0; /* empty */
+ }
+
*type = type_guess;
return 1;
}
--- ./slpd/Makefile.am.orig 2002-03-19 23:52:15.000000000 +0000
+++ ./slpd/Makefile.am 2006-11-16 16:19:30.000000000 +0000
@@ -38,6 +38,7 @@ slpd_regfile.c \
slpd_knownda.c \
slpd_incoming.c \
slpd_outgoing.c \
+slpd_mdns.c \
slpd.h \
slpd_knownda.h \
slpd_process.h \
@@ -49,6 +50,7 @@ slpd_database.h \
slpd_outgoing.h \
slpd_regfile.h \
slpd_incoming.h \
+slpd_mdns.h \
slpd_socket.h
slpd_LDADD = ../common/libcommonslpd.la \
--- ./slpd/slpd_database.c.orig 2003-03-19 05:03:21.000000000 +0000
+++ ./slpd/slpd_database.c 2006-11-16 16:19:30.000000000 +0000
@@ -69,6 +69,13 @@
#include "slp_xmalloc.h"
#include "slp_pid.h"
+extern char *reg_file_dir;
+FILE *regfileFP;
+
+/*=========================================================================*/
+/* standard header files */
+/*=========================================================================*/
+#include <dirent.h>
/*=========================================================================*/
SLPDDatabase G_SlpdDatabase;
@@ -414,6 +421,8 @@ int SLPDDatabaseSrvRqstStart(SLPMessage
/* entry reg is the SrvReg message from the database */
entryreg = &(entry->msg->body.srvreg);
+ if ((entryreg->watchflags & SLP_REG_WATCH_DEAD) != 0)
+ continue;
/* check the service type */
if ( SLPCompareSrvType(srvrqst->srvtypelen,
@@ -548,6 +557,8 @@ int SLPDDatabaseSrvTypeRqstStart(SLPMess
/* entry reg is the SrvReg message from the database */
entryreg = &(entry->msg->body.srvreg);
+ if ((entryreg->watchflags & SLP_REG_WATCH_DEAD) != 0)
+ continue;
if ( SLPCompareNamingAuth(entryreg->srvtypelen,
entryreg->srvtype,
@@ -658,6 +669,8 @@ int SLPDDatabaseAttrRqstStart(SLPMessage
/* entry reg is the SrvReg message from the database */
entryreg = &(entry->msg->body.srvreg);
+ if ((entryreg->watchflags & SLP_REG_WATCH_DEAD) != 0)
+ continue;
if ( SLPCompareString(attrrqst->urllen,
@@ -775,18 +788,19 @@ SLPMessage SLPDDatabaseEnum(void* eh, SL
/*=========================================================================*/
{
SLPDatabaseEntry* entry;
- entry = SLPDatabaseEnum((SLPDatabaseHandle) eh);
- if ( entry )
+ SLPSrvReg* entryreg;
+
+ while ((entry = SLPDatabaseEnum((SLPDatabaseHandle) eh)) != 0)
{
+ entryreg = &(entry->msg->body.srvreg);
+ if ((entryreg->watchflags & SLP_REG_WATCH_DEAD) != 0)
+ continue;
*msg = entry->msg;
*buf = entry->buf;
+ return *msg;
}
- else
- {
- *msg = 0;
- *buf = 0;
- }
-
+ *msg = 0;
+ *buf = 0;
return *msg;
}
@@ -840,12 +854,141 @@ int SLPDDatabaseInit(const char* regfile
SLPDatabaseInit(&G_SlpdDatabase.database);
/* Call the reinit function */
- return SLPDDatabaseReInit(regfile);
+ if (regfileFP)
+ {
+ fclose(regfileFP);
+ }
+ regfileFP = fopen(regfile, "r");
+ return SLPDDatabaseReInit();
}
+/*=========================================================================*/
+static void SLPDDatabaseWatcher_fd(int fd, int flag, unsigned char *porthash)
+{
+ SLPDatabaseHandle dh;
+ SLPDatabaseEntry* entry;
+ SLPSrvReg* srvreg;
+ char buf[4096], *p[6];
+ int l, o, i, j, k, c, n, port;
+
+ if (fd < 0)
+ return;
+ lseek(fd, (off_t)0, SEEK_SET);
+ o = 0;
+ while ((l = read(fd, buf + o, sizeof(buf) - o)) > 0) {
+ l += o;
+ n = 0;
+ for (;;) {
+ for (i = n; i < l; i++)
+ if (buf[i] == '\n')
+ break;
+ if (i == l) {
+ if (l > n)
+ memmove(buf, buf + n, l - n);
+ o = l > n ? l - n : 0;
+ break;
+ }
+ k = 0;
+ for (j = n; j < i; j++) {
+ c = buf[j];
+ if (!(c >= '0' && c <= '9') && !(c >= 'A' && c <= 'F') && !(c >= 'a' && c <= 'f'))
+ buf[j] = 0;
+ else if ((j == n || buf[j - 1] == 0) && k < 6)
+ p[k++] = buf + j;
+ }
+ n = i + 1;
+ if (k < 6 || strlen(p[1]) < 8)
+ continue;
+ if (strlen(p[1]) == 8 && strtol(p[1], (char **)0, 16) == htonl(0x7f000001))
+ continue;
+ if ((flag & SLP_REG_WATCH_TCP) != 0 && strtol(p[5], (char **)0, 16) != 10)
+ continue;
+ port = strtol(p[2], (char **)0, 16);
+ if (!(porthash[(port / 8) & 255] & (1 << (port & 7))))
+ continue;
+ dh = SLPDatabaseOpen(&G_SlpdDatabase.database);
+ while ((entry = SLPDatabaseEnum(dh)) != 0) {
+ srvreg = &(entry->msg->body.srvreg);
+ if (!(srvreg->watchflags & flag))
+ continue;
+ if (port == srvreg->watchport)
+ srvreg->watchflags &= ~SLP_REG_WATCH_CHECKING;
+ }
+ SLPDatabaseClose(dh);
+ }
+ }
+}
/*=========================================================================*/
-int SLPDDatabaseReInit(const char* regfile)
+void SLPDDatabaseWatcher(void)
+{
+ static int initialized = 0;
+ static int proctcp, procudp, proctcp6, procudp6;
+ unsigned char porthash[256];
+ int flags, port;
+ SLPDatabaseHandle dh;
+ SLPDatabaseEntry* entry;
+ SLPSrvReg* srvreg;
+
+ if (!initialized) {
+ proctcp = open("/proc/net/tcp_listen", O_RDONLY);
+ if (proctcp == -1)
+ proctcp = open("/proc/net/tcp", O_RDONLY);
+ procudp = open("/proc/net/udp", O_RDONLY);
+ proctcp6 = open("/proc/net/tcp6_listen", O_RDONLY);
+ if (proctcp6 == -1)
+ proctcp6 = open("/proc/net/tcp6", O_RDONLY);
+ procudp6 = open("/proc/net/udp6", O_RDONLY);
+ initialized = 1;
+ }
+ flags = 0;
+ memset(porthash,0,sizeof(porthash));
+ dh = SLPDatabaseOpen(&G_SlpdDatabase.database);
+ while ((entry = SLPDatabaseEnum(dh)) != 0) {
+ srvreg = &(entry->msg->body.srvreg);
+ if (!srvreg->watchflags)
+ continue;
+ flags |= srvreg->watchflags;
+ port = srvreg->watchport;
+ porthash[(port / 8) & 255] |= 1 << (port & 7);
+ srvreg->watchflags |= SLP_REG_WATCH_CHECKING;
+ }
+ SLPDatabaseClose(dh);
+ if ((flags & SLP_REG_WATCH_TCP) != 0) {
+ SLPDDatabaseWatcher_fd(proctcp, SLP_REG_WATCH_TCP, porthash);
+ SLPDDatabaseWatcher_fd(proctcp6, SLP_REG_WATCH_TCP, porthash);
+ }
+ if ((flags & SLP_REG_WATCH_UDP) != 0) {
+ SLPDDatabaseWatcher_fd(procudp, SLP_REG_WATCH_UDP, porthash);
+ SLPDDatabaseWatcher_fd(procudp6, SLP_REG_WATCH_UDP, porthash);
+ }
+ dh = SLPDatabaseOpen(&G_SlpdDatabase.database);
+ while ((entry = SLPDatabaseEnum(dh)) != 0) {
+ srvreg = &(entry->msg->body.srvreg);
+ if (!srvreg->watchflags)
+ continue;
+ switch (srvreg->watchflags & (SLP_REG_WATCH_CHECKING | SLP_REG_WATCH_DEAD)) {
+ case SLP_REG_WATCH_CHECKING:
+ srvreg->watchflags |= SLP_REG_WATCH_DEAD;
+ SLPDKnownDADeRegisterWithAllDas(entry->msg, entry->buf);
+ SLPDLogRegistration("port dead",entry);
+ break;
+ case SLP_REG_WATCH_DEAD:
+ srvreg->watchflags ^= SLP_REG_WATCH_DEAD;
+ SLPDKnownDARegisterWithAllDas(entry->msg, entry->buf);
+ SLPDLogRegistration("port living",entry);
+ break;
+ }
+ srvreg->watchflags &= ~SLP_REG_WATCH_CHECKING;
+ }
+ SLPDatabaseClose(dh);
+}
+
+
+
+
+/*=========================================================================*/
+int SLPDDatabaseReInit()
/* Re-initialize the database with changed registrations from a regfile. */
/* */
/* regfile (IN) the regfile to register. */
@@ -857,6 +1000,8 @@ int SLPDDatabaseReInit(const char* regfi
SLPDatabaseEntry* entry;
SLPMessage msg;
SLPBuffer buf;
+ struct dirent *direntry;
+ DIR *dirfp;
FILE* fd;
/*------------------------------------------------------------------*/
@@ -882,19 +1027,40 @@ int SLPDDatabaseReInit(const char* regfi
/*--------------------------------------*/
/* Read static registration file if any */
/*--------------------------------------*/
- if ( regfile )
+ if ( regfileFP )
{
- fd = fopen(regfile,"rb");
- if ( fd )
+ rewind(regfileFP);
+ while ( SLPDRegFileReadSrvReg(regfileFP, &msg, &buf) == 0 )
{
- while ( SLPDRegFileReadSrvReg(fd, &msg, &buf) == 0 )
- {
- SLPDDatabaseReg(msg, buf);
- }
+ SLPDDatabaseReg(msg, buf);
+ }
+ }
- fclose(fd);
+ /*------------------------------------------------------------------*/
+ /* Read all static registration file, which comes with any package */
+ /* SuSE ONLY */
+ /*------------------------------------------------------------------*/
+ dirfp = opendir(reg_file_dir);
+ while ( dirfp && (direntry = readdir(dirfp)) != 0) {
+ if ( direntry->d_name && direntry->d_name[0] != '.' ){
+ char filename[1024];
+ snprintf( filename, 1023, "%s/%s", reg_file_dir, direntry->d_name );
+
+ if ( strlen(filename)>4 &&
+ strcmp(filename+strlen(filename)-4, ".reg") == 0 &&
+ (fd=fopen(filename,"rb")) )
+ {
+ while ( SLPDRegFileReadSrvReg(fd, &msg, &buf) == 0 )
+ {
+ SLPDDatabaseReg(msg, buf);
+ }
+
+ fclose(fd);
+ }
}
- }
+ }
+ if ( dirfp )
+ closedir(dirfp);
return 0;
}
--- ./slpd/slpd_database.h.orig 2001-05-10 15:04:19.000000000 +0000
+++ ./slpd/slpd_database.h 2006-11-16 16:19:30.000000000 +0000
@@ -266,7 +266,7 @@ int SLPDDatabaseIsEmpty();
/*=========================================================================*/
-int SLPDDatabaseInit(const char* regfile);
+int SLPDDatabaseInit();
/* Initialize the database with registrations from a regfile. */
/* */
/* regfile (IN) the regfile to register. Pass in NULL for no regfile */
@@ -276,7 +276,7 @@ int SLPDDatabaseInit(const char* regfile
/*=========================================================================*/
-int SLPDDatabaseReInit(const char* regfile);
+int SLPDDatabaseReInit();
/* Re-initialize the database with changed registrations from a regfile. */
/* */
/* regfile (IN) the regfile to register. */
@@ -284,6 +284,8 @@ int SLPDDatabaseReInit(const char* regfi
/* Returns - zero on success or non-zero on error. */
/*=========================================================================*/
+void SLPDDatabaseWatcher(void);
+
#ifdef DEBUG
/*=========================================================================*/
void SLPDDatabaseDeinit(void);
--- ./slpd/slpd_knownda.c.orig 2003-02-04 20:41:15.000000000 +0000
+++ ./slpd/slpd_knownda.c 2006-11-16 16:19:30.000000000 +0000
@@ -1640,7 +1640,7 @@ void SLPDKnownDARegisterWithAllDas(SLPMe
/* Returns: None */
/*=========================================================================*/
{
- if (msg->header.functionid == SLP_FUNCT_SRVDEREG)
+ if (msg->header.functionid == SLP_FUNCT_SRVREG)
{
/* Simply echo the message through as is */
SLPDKnownDAEcho(msg,buf);
--- ./slpd/slpd_log.c.orig 2002-12-03 21:04:53.000000000 +0000
+++ ./slpd/slpd_log.c 2006-11-16 16:19:30.000000000 +0000
@@ -271,6 +271,7 @@ void SLPDLogSrvTypeRqstMessage(SLPSrvTyp
/*-------------------------------------------------------------------------*/
{
SLPDLog("Message SRVTYPERQST:\n");
+ SLPDLogBuffer(" scope = ", srvtyperqst->scopelistlen, srvtyperqst->scopelist);
}
/*-------------------------------------------------------------------------*/
--- ./slpd/slpd_main.c.orig 2002-12-03 21:04:53.000000000 +0000
+++ ./slpd/slpd_main.c 2006-11-16 16:19:30.000000000 +0000
@@ -54,6 +54,7 @@
#include "slpd_log.h"
#include "slpd_socket.h"
#include "slpd_incoming.h"
+#include "slpd_mdns.h"
#include "slpd_outgoing.h"
#include "slpd_database.h"
#include "slpd_cmdline.h"
@@ -73,7 +74,9 @@
/*==========================================================================*/
int G_SIGALRM;
int G_SIGTERM;
-int G_SIGHUP;
+int G_SIGHUP;
+char *reg_file_dir;
+
#ifdef DEBUG
int G_SIGINT; /* Signal being used for dumping registrations */
#endif
@@ -160,6 +163,9 @@ void HandleSigTerm()
/* close all incoming sockets */
SLPDIncomingDeinit();
+#ifdef ENABLE_MDNS_SLPD
+ SLPDMDNSDeinit();
+#endif
/* unregister with all DAs */
SLPDKnownDADeinit();
@@ -218,15 +224,22 @@ void HandleSigHup()
SLPDKnownDADeinit();
/* re-read properties */
+#if 0
SLPDPropertyInit(G_SlpdCommandLine.cfgfile);
+#else
+ SLPDPropertyInit((char *)0);
+#endif
#ifdef ENABLE_SLPv2_SECURITY
+ /* does not work in chroot, sorry */
+# if 0
/* Re-initialize SPI stuff*/
SLPDSpiInit(G_SlpdCommandLine.spifile);
+# endif
#endif
/* Re-read the static registration file (slp.reg)*/
- SLPDDatabaseReInit(G_SlpdCommandLine.regfile);
+ SLPDDatabaseReInit();
/* Rebuild Known DA database */
SLPDKnownDAInit();
@@ -247,6 +260,7 @@ void HandleSigAlrm()
SLPDKnownDAPassiveDAAdvert(SLPD_AGE_INTERVAL,0);
SLPDKnownDAActiveDiscovery(SLPD_AGE_INTERVAL);
SLPDDatabaseAge(SLPD_AGE_INTERVAL,G_SlpdProperty.isDA);
+ SLPDDatabaseWatcher();
}
@@ -377,11 +391,21 @@ int Daemonize(const char* pidfile)
close(2);
setsid(); /* will only fail if we are already the process group leader */
+ pwent = getpwnam("daemon");
+ /*---------------------*/
+ /* chroot to slp.reg.d */
+ /*---------------------*/
+ if (chroot(reg_file_dir))
+ {
+ exit(1);
+ }
+ free(reg_file_dir);
+ reg_file_dir = strdup(".");
+
/*----------------*/
/* suid to daemon */
/*----------------*/
/* TODO: why do the following lines mess up my signal handlers? */
- pwent = getpwnam("daemon");
if(pwent)
{
if(setgroups(1, &pwent->pw_gid) < 0 ||
@@ -389,7 +413,10 @@ int Daemonize(const char* pidfile)
setuid(pwent->pw_uid) < 0)
{
/* TODO: should we log here and return fail */
+ exit(1);
}
+ }else{
+ exit(1);
}
/*--------------------*/
@@ -469,6 +496,8 @@ int main(int argc, char* argv[])
int highfd;
int fdcount = 0;
+ reg_file_dir = strdup("/etc/slp.reg.d");
+
#ifdef DEBUG
xmalloc_init("/var/log/slpd_xmalloc.log",0);
#endif
@@ -534,6 +563,9 @@ int main(int argc, char* argv[])
#endif
SLPDDatabaseInit(G_SlpdCommandLine.regfile) ||
SLPDIncomingInit() ||
+#ifdef ENABLE_MDNS_SLPD
+ SLPDMDNSInit() ||
+#endif
SLPDOutgoingInit() ||
SLPDKnownDAInit())
{
@@ -543,6 +575,11 @@ int main(int argc, char* argv[])
SLPDLog("Agent URL = %s\n",G_SlpdProperty.myUrl);
/*---------------------------*/
+ /* init watcher */
+ /*---------------------------*/
+ SLPDDatabaseWatcher();
+
+ /*---------------------------*/
/* make slpd run as a daemon */
/*---------------------------*/
if(Daemonize(G_SlpdCommandLine.pidfile))
@@ -585,6 +622,10 @@ int main(int argc, char* argv[])
LoadFdSets(&G_IncomingSocketList, &highfd, &readfds,&writefds);
LoadFdSets(&G_OutgoingSocketList, &highfd, &readfds,&writefds);
+#ifdef ENABLE_MDNS_SLPD
+ LoadFdSets(&G_MDNSSocketList, &highfd, &readfds,&writefds);
+#endif
+
/*--------------------------------------------------*/
/* Before select(), check to see if we got a signal */
/*--------------------------------------------------*/
@@ -601,6 +642,10 @@ int main(int argc, char* argv[])
{
SLPDIncomingHandler(&fdcount,&readfds,&writefds);
SLPDOutgoingHandler(&fdcount,&readfds,&writefds);
+
+#ifdef ENABLE_MDNS_SLPD
+ SLPDMDNSHandler(&fdcount,&readfds,&writefds);
+#endif
}
/*----------------*/
--- ./slpd/slpd_mdns.c.orig 2006-11-16 16:19:30.000000000 +0000
+++ ./slpd/slpd_mdns.c 2006-11-16 16:19:30.000000000 +0000
@@ -0,0 +1,906 @@
+#include "slpd_mdns.h"
+#include "slpd_socket.h"
+#include "slpd_property.h"
+#include "slpd_database.h"
+#include "slpd_log.h"
+
+#include "slp_compare.h"
+#ifdef ENABLE_PREDICATES
+# include "slpd_predicate.h"
+#endif
+
+
+extern SLPDDatabase G_SlpdDatabase;
+
+extern int JoinSLPMulticastGroup(sockfd_t sockfd, struct in_addr* maddr,
+ struct in_addr* addr);
+extern int EnableBroadcast(sockfd_t sockfd);
+
+
+#define MDNS_MAX_DATAGRAM_SIZE 8000
+
+/*=========================================================================*/
+/* common code includes */
+/*=========================================================================*/
+#include "slp_xmalloc.h"
+
+
+static void MDNSDatagramRead(SLPList* socklist, SLPDSocket* sock);
+static int MDNSHandleSrvTypeRqst(SLPBuffer buf, SLPBuffer obuf, unsigned char *q, int qtype, unsigned char **an, unsigned char **ad, int ac, int mdnspeer, unsigned char *txtbuf, int txtlen);
+static int MDNSHandleSrvsRqst(SLPBuffer buf, SLPBuffer obuf, unsigned char *q, int qtype, unsigned char **an, unsigned char **ad, int ac, int mdnspeer, unsigned char *txtbuf, int txtlen, struct sockaddr_in *);
+static int MDNSHandleARqst(SLPBuffer buf, SLPBuffer obuf, unsigned char *q, int qtype, unsigned char **an, unsigned char **ad, int ac, int mdnspeer, struct sockaddr_in *ifaddr);
+
+
+SLPList G_MDNSSocketList = {0,0,0};
+
+
+SLPDSocket* SLPDMDNSCreateBoundDatagram(struct in_addr* myaddr,
+ struct in_addr* peeraddr,
+ int type)
+{
+ SLPDSocket* sock;
+ struct in_addr* bindaddr;
+ struct sockaddr_in mysockaddr;
+#ifdef _WIN32
+ BOOL reuse = TRUE;
+#else
+ int reuse = 1;
+#endif
+ unsigned char ttl = 255;
+
+ /*------------------------------------------*/
+ /* Adjust for multicast binding differences */
+ /*------------------------------------------*/
+#ifdef LINUX
+ bindaddr = peeraddr;
+#else
+ if(type == DATAGRAM_MULTICAST)
+ bindaddr = NULL; /* must bind to INADDR_ANY for multicast */
+ else
+ bindaddr = peeraddr;
+#endif
+
+ /*------------------------*/
+ /* Create and bind socket */
+ /*------------------------*/
+ sock = SLPDSocketAlloc();
+ if (!sock)
+ return 0;
+ if (myaddr)
+ sock->ifaddr.sin_addr = *myaddr;
+ sock->recvbuf = SLPBufferAlloc(MDNS_MAX_DATAGRAM_SIZE);
+ sock->sendbuf = SLPBufferAlloc(MDNS_MAX_DATAGRAM_SIZE);
+ sock->fd = socket(PF_INET, SOCK_DGRAM, 0);
+ if (sock->fd < 0)
+ {
+ SLPDSocketFree(sock);
+ return 0;
+ }
+ memset(&mysockaddr, 0, sizeof(mysockaddr));
+ mysockaddr.sin_family = AF_INET;
+ mysockaddr.sin_port = htons(MDNS_RESERVED_PORT);
+ mysockaddr.sin_addr.s_addr = INADDR_ANY;
+ if (bindaddr)
+ mysockaddr.sin_addr = *bindaddr;
+ setsockopt(sock->fd,SOL_SOCKET,SO_REUSEADDR,(const char *)&reuse,sizeof(reuse));
+ setsockopt(sock->fd,SOL_IP,IP_TTL,(const char *)&ttl,sizeof(ttl));
+ setsockopt(sock->fd,SOL_IP,IP_MULTICAST_TTL,(const char *)&ttl,sizeof(ttl));
+ if (bind(sock->fd, (struct sockaddr *) &mysockaddr,sizeof(mysockaddr)))
+ {
+ SLPDSocketFree(sock);
+ return 0;
+ }
+ if(peeraddr != NULL)
+ sock->peeraddr.sin_addr = *peeraddr;
+ switch(type)
+ {
+ case DATAGRAM_MULTICAST:
+ if(JoinSLPMulticastGroup(sock->fd, peeraddr, myaddr) == 0)
+ {
+ sock->state = DATAGRAM_MULTICAST;
+ return sock;
+ }
+ break;
+ case DATAGRAM_BROADCAST:
+ if(EnableBroadcast(sock->fd) == 0)
+ {
+ sock->state = DATAGRAM_BROADCAST;
+ return sock;
+ }
+ break;
+ case DATAGRAM_UNICAST:
+ default:
+ sock->state = DATAGRAM_UNICAST;
+ return sock;
+ }
+ SLPDSocketFree(sock);
+ return 0;
+}
+
+int SLPDMDNSInit(void)
+{
+ int iface;
+ struct in_addr myaddr;
+ struct in_addr mcastaddr;
+ SLPDSocket* sock;
+
+ /*------------------------------------------------------------*/
+ /* First, remove all of the sockets that might be in the list */
+ /*------------------------------------------------------------*/
+ while (G_MDNSSocketList.count)
+ {
+ SLPDSocketFree((SLPDSocket*)SLPListUnlink(&G_MDNSSocketList,G_MDNSSocketList.head));
+ }
+
+ /*----------------------------------------------------------------*/
+ /* Create sockets for all of the interfaces in the interface list */
+ /*----------------------------------------------------------------*/
+ mcastaddr.s_addr = htonl(MDNS_MCAST_ADDRESS);
+
+ for (iface = 0; iface < G_SlpdProperty.ifaceInfo.iface_count; iface++)
+ {
+ myaddr = G_SlpdProperty.ifaceInfo.iface_addr[iface].sin_addr;
+
+ /*----------------------------------------------------------------*/
+ /* Create socket that will handle multicast UDP. */
+ /*----------------------------------------------------------------*/
+
+ sock = SLPDMDNSCreateBoundDatagram(&myaddr,
+ &mcastaddr,
+ DATAGRAM_MULTICAST);
+ if (sock)
+ {
+ SLPListLinkTail(&G_MDNSSocketList,(SLPListItem*)sock);
+ SLPDLog("Multicast MDNS socket on %s ready\n",inet_ntoa(myaddr));
+ }
+ else
+ {
+ SLPDLog("Couldn't bind to multicast MDNS for interface %s (%s)\n",
+ inet_ntoa(myaddr), strerror(errno));
+ }
+
+ /*--------------------------------------------*/
+ /* Create socket that will handle unicast UDP */
+ /*--------------------------------------------*/
+ sock = SLPDMDNSCreateBoundDatagram(&myaddr,
+ &myaddr,
+ DATAGRAM_UNICAST);
+ if (sock)
+ {
+ SLPListLinkTail(&G_MDNSSocketList,(SLPListItem*)sock);
+ SLPDLog("Unicast MDNS socket on %s ready\n",inet_ntoa(myaddr));
+ }
+ }
+
+ if (G_MDNSSocketList.count == 0)
+ {
+ SLPDLog("No usable MDNS interfaces\n");
+ return 1;
+ }
+
+ return 0;
+}
+
+/*=========================================================================*/
+int SLPDMDNSDeinit()
+/* Deinitialize incoming socket list to have appropriate sockets for all */
+/* network interfaces */
+/* */
+/* Returns Zero on success non-zero on error */
+/*=========================================================================*/
+{
+ SLPDSocket* del = 0;
+ SLPDSocket* sock = (SLPDSocket*)G_MDNSSocketList.head;
+ while (sock)
+ {
+ del = sock;
+ sock = (SLPDSocket*)sock->listitem.next;
+ if (del)
+ {
+ SLPDSocketFree((SLPDSocket*)SLPListUnlink(&G_MDNSSocketList,(SLPListItem*)del));
+ del = 0;
+ }
+ }
+
+ return 0;
+}
+
+/*=========================================================================*/
+void SLPDMDNSHandler(int* fdcount,
+ fd_set* readfds,
+ fd_set* writefds)
+/* Handles all outgoing requests that are pending on the specified file */
+/* discriptors */
+/* */
+/* fdcount (IN/OUT) number of file descriptors marked in fd_sets */
+/* */
+/* readfds (IN) file descriptors with pending read IO */
+/* */
+/* writefds (IN) file descriptors with pending read IO */
+/*=========================================================================*/
+{
+ SLPDSocket* sock;
+ sock = (SLPDSocket*) G_MDNSSocketList.head;
+ while (sock && *fdcount)
+ {
+ if (FD_ISSET(sock->fd,readfds))
+ {
+ switch (sock->state)
+ {
+ case DATAGRAM_UNICAST:
+ case DATAGRAM_MULTICAST:
+ case DATAGRAM_BROADCAST:
+ MDNSDatagramRead(&G_MDNSSocketList,sock);
+ break;
+ default:
+ break;
+ }
+
+ *fdcount = *fdcount - 1;
+ }
+ sock = (SLPDSocket*)sock->listitem.next;
+ }
+}
+
+
+/*-------------------------------------------------------------------------*/
+static void MDNSDatagramRead(SLPList* socklist, SLPDSocket* sock)
+/*-------------------------------------------------------------------------*/
+{
+ int bytesread;
+ int bytestowrite;
+ int byteswritten;
+ int peeraddrlen = sizeof(struct sockaddr_in);
+ int qcount, acount, ncount, xcount;
+ unsigned char *bp, *end;
+ SLPBuffer buf;
+ int mdnspeer;
+ int qtype = 0;
+ int qclass = 0;
+ unsigned char * an[SLP_MDNS_MAX_RR];
+ unsigned char * ad[SLP_MDNS_MAX_RR];
+ int ac;
+ int result;
+ unsigned char * txtbuf = 0;
+ int txtlen = 0;
+
+
+ buf = sock->recvbuf;
+ bytesread = recvfrom(sock->fd,
+ buf->start,
+ MDNS_MAX_DATAGRAM_SIZE,
+ 0,
+ (struct sockaddr *) &(sock->peeraddr),
+ &peeraddrlen);
+ if (bytesread < 12)
+ return;
+ buf->end = buf->start + bytesread;
+#ifdef DEBUG
+ SLPMDNSDumpDNS(buf, "mdns incoming");
+#endif
+
+ if ((buf->start[2] & 0xf0) != 0x00)
+ return; /* no standard query */
+
+ qcount = AsUINT16(buf->start + 4);
+ if (qcount > 1)
+ return; /* not supported at the moment */
+ if (qcount == 0)
+ return; /* no query to answer */
+ acount = AsUINT16(buf->start + 6);
+ ncount = AsUINT16(buf->start + 8);
+ xcount = AsUINT16(buf->start + 10);
+
+ bp = (unsigned char *)buf->start + 12;
+ /* skip query section */
+ end = buf->end;
+ if (qcount)
+ {
+ while (bp < end && *bp && (*bp & 0xc0) != 0xc0)
+ bp += *bp + 1;
+ if (bp < end && *bp)
+ bp++;
+ bp += 5;
+ if (bp <= end)
+ {
+ qtype = AsUINT16(bp - 4);
+ qclass = AsUINT16(bp - 2);
+ }
+ }
+ bp = SLPMDNSParseRR(bp, end, acount, an, ad, &ac);
+ if (bp > end)
+ return;
+ bp = SLPMDNSParseRR(bp, end, ncount, 0, 0, 0);
+ bp = SLPMDNSParseRR(bp, end, xcount, 0, 0, 0);
+
+ /* validate DNS request */
+ if (qcount > 0 && SLPMDNSCheckN(buf->start, bp > end ? end : bp, buf->start + 12, 0))
+ return;
+ if (SLPMDNSCheckRR(buf->start, bp > end ? end : bp, an, ad, &ac))
+ return;
+
+ if (qcount == 0)
+ return;
+ if (qclass != DNS_CLASS_IN && qclass != DNS_CLASS_ANY)
+ return;
+ mdnspeer = (sock->peeraddr.sin_port == htons(MDNS_RESERVED_PORT));
+
+ if (qtype == DNS_TYPE_ANY || qtype == DNS_TYPE_A)
+ {
+ unsigned char myhostname[256];
+ if (MDNSStrToN(myhostname, myhostname + sizeof(myhostname), G_SlpdProperty.myHostname, G_SlpdProperty.myHostnameLen))
+ {
+ if (!SLPMDNSCmpN(buf->start + 12, buf->start, myhostname, 0))
+ {
+ result = MDNSHandleARqst(buf, sock->sendbuf, buf->start + 12, qtype, an, ad, ac, mdnspeer, &sock->ifaddr);
+ goto reply;
+ }
+ }
+ }
+
+ if (qtype != DNS_TYPE_PTR && qtype != DNS_TYPE_ANY)
+ return;
+ if (ac > 0 && !memcmp(an[0], "\011_slpquery\300\014", 12) && AsUINT16(ad[0]) == DNS_TYPE_TXT)
+ {
+ txtlen = AsUINT16(ad[0] + 8);
+ txtbuf = ad[0] + 10;
+ }
+
+ if (!SLPMDNSCmpN(buf->start + 12, buf->start, "\011_services\007_dns-sd\004_udp\005local\000", 0))
+ {
+ result = MDNSHandleSrvTypeRqst(buf, sock->sendbuf, buf->start + 12, qtype, an, ad, ac, mdnspeer, txtbuf, txtlen);
+ }
+ else
+ {
+ result = MDNSHandleSrvsRqst(buf, sock->sendbuf, buf->start + 12, qtype, an, ad, ac, mdnspeer, txtbuf, txtlen, &sock->ifaddr);
+ }
+
+reply:
+ if (result)
+ return;
+
+ bytestowrite = sock->sendbuf->end - sock->sendbuf->start;
+ if (bytestowrite > 0)
+ {
+ byteswritten = sendto(sock->fd,
+ sock->sendbuf->start,
+ bytestowrite,
+ 0,
+ (struct sockaddr *)&(sock->peeraddr),
+ sizeof(struct sockaddr_in));
+ if (byteswritten != bytestowrite)
+ {
+ SLPDLog("NETWORK_ERROR - %d replying %s\n",
+ errno,
+ inet_ntoa(sock->peeraddr.sin_addr));
+ }
+ }
+
+}
+
+static int MDNSParseHostPort(const char *url, int urllen, const char **hostp, int *portp)
+{
+ int l, hl, port;
+
+ for (l = 0; l < urllen; l++)
+ if (l && url[l] == '/' && url[l - 1] == '/')
+ break;
+ l++;
+ if (l >= urllen)
+ return 0;
+ url += l;
+ urllen -= l;
+ if (hostp)
+ *hostp = url;
+ for (l = 0; l < urllen ; l++)
+ if (url[l] == '/' || url[l] == ':')
+ break;
+ if (l == urllen || url[l] != ':')
+ {
+ if (portp)
+ *portp = 0;
+ return l;
+ }
+ port = 0;
+ hl = l++;
+ url += l;
+ urllen -= l;
+ for (l = 0; l < urllen ; l++)
+ if (url[l] <= '0' || url[l] >= '9')
+ break;
+ else
+ port = port * 10 + (url[l] - '0');
+ if (l < urllen && url[l] != '/')
+ return 0;
+ if (portp)
+ *portp = port;
+ return hl;
+}
+
+
+static int MDNSHandleSrvTypeRqst(SLPBuffer buf, SLPBuffer obuf, unsigned char *q, int qtype, unsigned char **an, unsigned char **ad, int ac, int mdnspeer, unsigned char *txtbuf, int txtlen)
+{
+ SLPDatabaseHandle dh;
+ SLPDatabaseEntry* entry;
+ SLPSrvReg* entryreg;
+ char srvbuf[80];
+ unsigned char *md[SLP_MDNS_MAX_RR];
+ unsigned char *oend, *bp, *oldbp;
+ unsigned char *cvec[256];
+ int i, port;
+ int ncvec;
+ int nans;
+ char *nameauth;
+ int nameauthlen;
+
+ nameauthlen = 0xffff;
+ nameauth = SLPMDNSFindInTxt(txtbuf, txtlen, "namingauth=", &nameauthlen);
+
+ obuf->start[0] = buf->start[0]; /* xid */
+ obuf->start[1] = buf->start[1]; /* xid */
+ obuf->start[2] = 0x84;
+ obuf->start[3] = 0x00;
+ obuf->start[4] = obuf->start[5] = 0; /* qcount */
+ obuf->start[6] = obuf->start[7] = 0; /* acount */
+ obuf->start[8] = obuf->start[9] = 0; /* ncount */
+ obuf->start[10] = obuf->start[11] = 0; /* xcount */
+
+ ncvec = 0;
+ bp = obuf->start + 12;
+ oend = obuf->start + obuf->allocated;
+ if (!mdnspeer)
+ {
+ bp = SLPMDNSCompN(bp, oend, q, buf->start, cvec, &ncvec, obuf->start);
+ if (!bp || bp + 4 >= oend)
+ return 1;
+ *bp++ = 0;
+ *bp++ = qtype;
+ *bp++ = 0;
+ *bp++ = DNS_CLASS_IN;
+ obuf->start[5] = 1;
+ }
+
+ nans = 0;
+ dh = SLPDatabaseOpen(&G_SlpdDatabase.database);
+ while ((entry = SLPDatabaseEnum(dh)) != 0)
+ {
+ entryreg = &(entry->msg->body.srvreg);
+ if ((entryreg->watchflags & SLP_REG_WATCH_DEAD) != 0)
+ continue;
+
+ if (SLPCompareNamingAuth(entryreg->srvtypelen,
+ entryreg->srvtype,
+ nameauthlen,
+ nameauth))
+ continue;
+
+#if 0
+ if (!SLPContainsStringList(entryreg->scopelistlen, entryreg->scopelist, 5, "_mdns"))
+ continue;
+#endif
+
+ if (!MDNSParseHostPort(entryreg->urlentry.url, entryreg->urlentry.urllen, 0, &port))
+ continue;
+ if (!port)
+ continue;
+
+ if (!SLPMDNSSrvtypeToN(srvbuf, srvbuf + sizeof(srvbuf), entryreg->srvtype, entryreg->srvtypelen))
+ continue;
+
+ /* check if answer is already known in query */
+ for (i = 0; i < ac; i++)
+ if (AsUINT16(ad[i]) == DNS_TYPE_PTR &&
+ !SLPMDNSCmpN(ad[i] + 10, buf->start, srvbuf, 0))
+ break;
+ if (i < ac)
+ continue;
+
+ /* check if answer already in our packet */
+ for (i = 0; i < nans; i++)
+ if (!SLPMDNSCmpN(md[i] + 10, obuf->start, srvbuf, 0))
+ break;
+ if (i < nans)
+ continue;
+
+ /* new answer, add to return buffer */
+ oldbp = bp;
+ bp = SLPMDNSAddRR(bp, obuf->start, oend, q, buf->start,
+ DNS_TYPE_PTR, mdnspeer ? entryreg->urlentry.lifetime : 10,
+ cvec, &ncvec, 0, srvbuf, md + nans);
+ if (!bp)
+ {
+ bp = oldbp;
+ break;
+ }
+ if (++nans == SLP_MDNS_MAX_RR)
+ break;
+ }
+ ToUINT16(obuf->start + 6, nans);
+ SLPDatabaseClose(dh);
+ if (bp >= oend)
+ return 1;
+ if (nans)
+ {
+ obuf->end = bp;
+#ifdef DEBUG
+ SLPMDNSDumpDNS(obuf, "mdns outgoing");
+#endif
+ }
+ else
+ obuf->end = obuf->start;
+ return 0;
+}
+
+
+static void SLPDAddAttrs(unsigned char *txtbuf, int txtbuflen, int *txtlen, const char *attr, int attrlen, char *taglist, int taglistlen)
+{
+ const char *ts, *vs;
+ int tl, vl, i;
+
+ while (attrlen > 0)
+ {
+ if (*attr != '(')
+ {
+ /* keyword */
+ vs = 0;
+ vl = 0;
+ ts = attr;
+ for (i = 0; i < attrlen; i++)
+ if (attr[i] == ',')
+ break;
+ tl = i;
+ attr += i;
+ attrlen -= i;
+ }
+ else
+ {
+ /* (key=value,value...) */
+ attr++;
+ attrlen--;
+ ts = attr;
+ for (i = 0; i < attrlen; i++)
+ if (attr[i] == '=')
+ break;
+ tl = i;
+ attr += i + 1;
+ attrlen -= i + 1;
+ if (attrlen <= 0)
+ break;
+ vs = attr;
+ for (i = 0; i < attrlen; i++)
+ if (attr[i] == ')')
+ break;
+ if (i == attrlen)
+ break;
+ vl = i;
+ attr += i + 1;
+ attrlen -= i + 1;
+ }
+ if (!taglistlen || SLPContainsStringList(taglistlen, taglist, tl, ts))
+ {
+ if (tl + 1 + vl <= 255)
+ {
+ char tagbuf[256];
+ memcpy(tagbuf, ts, tl);
+ if (vs)
+ {
+ tagbuf[tl] = '=';
+ tl++;
+ }
+ tagbuf[tl] = 0;
+ SLPMDNSAddTxt(txtbuf, txtbuflen, txtlen, tagbuf, vs, vl);
+ }
+ }
+ if (attrlen)
+ {
+ attr++;
+ attrlen--;
+ }
+ }
+}
+
+static int MDNSHandleSrvsRqst(SLPBuffer buf, SLPBuffer obuf, unsigned char *q, int qtype, unsigned char **an, unsigned char **ad, int ac, int mdnspeer, unsigned char *txtbuf, int txtlen, struct sockaddr_in *ifaddr)
+{
+ SLPDatabaseHandle dh;
+ SLPDatabaseEntry* entry;
+ SLPSrvReg* entryreg;
+ SLPUrlEntry* urlentry;
+ char srvtype[256];
+ int srvtypelen;
+ int i;
+ unsigned char *bp, *oend;
+ unsigned char *cvec[256];
+ int ncvec;
+ const char *host;
+ int hostlen, hostlennq;
+ int port;
+ unsigned char ptr[256];
+ int nans;
+ unsigned char *oldbp;
+ unsigned char xbuf[8000];
+ unsigned char *xn[SLP_MDNS_MAX_RR];
+ unsigned char *xd[SLP_MDNS_MAX_RR];
+ unsigned char *xp, *xend;
+ int xc = 0;
+ unsigned char *rad[SLP_MDNS_MAX_RR];
+ int unify;
+#ifdef ENABLE_PREDICATES
+ int predlen;
+ char *pred;
+#endif
+ char *slpurl;
+ int slpurllen;
+ char *taglist;
+ int taglistlen;
+ unsigned char otxtbuf[512];
+ int otxtlen;
+
+ slpurllen = 0;
+ slpurl = SLPMDNSFindInTxt(txtbuf, txtlen, "slpurl=", &slpurllen);
+ taglistlen = 0;
+ taglist = SLPMDNSFindInTxt(txtbuf, txtlen, "taglist=", &taglistlen);
+
+#ifdef ENABLE_PREDICATES
+ predlen = 0;
+ pred = SLPMDNSFindInTxt(txtbuf, txtlen, "predicate=", &predlen);
+#endif
+
+ xp = xbuf;
+ xend = xbuf + sizeof(xbuf);
+
+ obuf->start[0] = buf->start[0]; /* xid */
+ obuf->start[1] = buf->start[1]; /* xid */
+ obuf->start[2] = 0x84;
+ obuf->start[3] = 0x00;
+ obuf->start[4] = obuf->start[5] = 0; /* qcount */
+ obuf->start[6] = obuf->start[7] = 0; /* acount */
+ obuf->start[8] = obuf->start[9] = 0; /* ncount */
+ obuf->start[10] = obuf->start[11] = 0; /* xcount */
+
+ ncvec = 0;
+ bp = obuf->start + 12;
+ oend = obuf->start + obuf->allocated;
+ if (!mdnspeer)
+ {
+ bp = SLPMDNSCompN(bp, oend, q, buf->start, cvec, &ncvec, obuf->start);
+ if (!bp || bp + 4 >= oend)
+ return 1;
+ *bp++ = 0;
+ *bp++ = qtype;
+ *bp++ = 0;
+ *bp++ = DNS_CLASS_IN;
+ obuf->start[5] = 1;
+ }
+ /* convert query in srvtype (query is already checked) */
+ srvtypelen = SLPMDNSNToSrvtype(q, buf->start, srvtype, sizeof(srvtype) - 1);
+ if (srvtypelen == 0)
+ return 1;
+ srvtype[srvtypelen] = 0;
+ /* printf("srvtype: %s\n", srvtype); */
+
+ nans = 0;
+ dh = SLPDatabaseOpen(&G_SlpdDatabase.database);
+ while ((entry = SLPDatabaseEnum(dh)) != 0)
+ {
+ entryreg = &(entry->msg->body.srvreg);
+ if ((entryreg->watchflags & SLP_REG_WATCH_DEAD) != 0)
+ continue;
+ urlentry = &entryreg->urlentry;
+
+ /* limit to one exact url, used for AttrRqst */
+ if (slpurllen && SLPCompareString(urlentry->urllen, urlentry->url, slpurllen, slpurl))
+ continue;
+
+ /* limit to matching srvtypes */
+ if (!slpurllen && SLPCompareSrvType(srvtypelen,
+ srvtype,
+ entryreg->srvtypelen,
+ entryreg->srvtype) != 0)
+ continue;
+
+#ifdef ENABLE_PREDICATES
+ if (!SLPDPredicateTest(2,
+ entryreg->attrlistlen,
+ entryreg->attrlist,
+ predlen,
+ pred))
+ continue;
+#endif
+
+ otxtlen = 0;
+
+ /* printf("HIT: %.*s\n", urlentry->urllen, urlentry->url); */
+
+ hostlen = MDNSParseHostPort(urlentry->url, urlentry->urllen, &host, &port);
+ if (!hostlen || !port)
+ continue;
+ if (*host >= '0' && *host <= '9')
+ hostlennq = hostlen;
+ else
+ for (hostlennq = 0; hostlennq < hostlen; hostlennq++)
+ if (host[hostlennq] == '.')
+ break;
+ if (hostlennq == 0 || hostlennq > 63)
+ continue;
+
+ /* create an unique name */
+ for (unify = 0; unify < SLP_MDNS_MAX_RR; unify++)
+ {
+ ptr[0] = hostlennq;
+ memcpy(ptr + 1, host, hostlennq);
+ if (unify)
+ {
+ /* will always fit into ptr, as hostlennq < 64 */
+ sprintf(ptr + 1 + hostlennq, "_%d", unify == 1 ? port : unify);
+ i = strlen(ptr + 1);
+ if (i > 63)
+ break;
+ ptr[0] = i;
+ }
+ /* append query name */
+ if (!SLPMDNSCopyN(ptr + 1 + *ptr, ptr + sizeof(ptr), q, buf->start))
+ break;
+ for (i = 0; i < nans; i++)
+ if (!SLPMDNSCmpN(rad[i] + 10, obuf->start, ptr, 0))
+ break;
+ if (i == nans)
+ {
+ unify = -1;
+ break;
+ }
+ }
+ if (unify != -1)
+ continue;
+
+ /* check if it is already in the answer section of the query */
+ for (i = 0; i < ac; i++)
+ if (AsUINT16(ad[i]) == DNS_TYPE_PTR &&
+ !SLPMDNSCmpN(ad[i] + 10, buf->start, ptr, 0))
+ break;
+ if (i < ac)
+ continue;
+
+ /* great, a new entry */
+ oldbp = bp;
+ bp = SLPMDNSAddRR(bp, obuf->start, oend, q, buf->start,
+ DNS_TYPE_PTR, mdnspeer ? urlentry->lifetime : 10,
+ cvec, &ncvec, 0, ptr, rad + nans);
+ if (!bp)
+ {
+ bp = oldbp;
+ break;
+ }
+
+ /* set up extra answers */
+ if (xp && xc < SLP_MDNS_MAX_RR)
+ {
+ unsigned char data[256];
+ if (!MDNSStrToN(data, data + sizeof(data), host, hostlen))
+ continue;
+ xn[xc] = xp;
+ xp = SLPMDNSAddRR(xp, 0, xend, ptr, obuf->start,
+ DNS_TYPE_SRV, mdnspeer ? urlentry->lifetime : 10,
+ 0, 0, port, data, xd + xc);
+ if (xp)
+ xc++;
+ }
+ SLPMDNSAddTxt(otxtbuf, sizeof(otxtbuf), &otxtlen, "slpurl=", urlentry->url, urlentry->urllen);
+ SLPDAddAttrs(otxtbuf, sizeof(otxtbuf), &otxtlen, entryreg->attrlist, entryreg->attrlistlen, taglist, taglistlen);
+ if (xp && xc < SLP_MDNS_MAX_RR && otxtlen)
+ {
+ xn[xc] = xp;
+ xp = SLPMDNSAddRR(xp, 0, xend, ptr, obuf->start,
+ DNS_TYPE_TXT, mdnspeer ? urlentry->lifetime : 10,
+ 0, 0, otxtlen, otxtbuf, xd + xc);
+ if (xp)
+ xc++;
+ }
+ if (++nans == SLP_MDNS_MAX_RR)
+ break;
+ }
+ ToUINT16(obuf->start + 6, nans);
+ SLPDatabaseClose(dh);
+ if (bp >= oend)
+ return 1;
+
+ /* add an A RR of our hostname to x info */
+ if (nans && xp && xc < SLP_MDNS_MAX_RR)
+ {
+ unsigned char myhostname[256];
+ if (MDNSStrToN(myhostname, myhostname + sizeof(myhostname), G_SlpdProperty.myHostname, G_SlpdProperty.myHostnameLen))
+ {
+ xn[xc] = xp;
+ xp = SLPMDNSAddRR(xp, 0, xend, myhostname, 0,
+ DNS_TYPE_A, 10,
+ 0, 0, 4, (unsigned char *)&ifaddr->sin_addr,
+ xd + xc);
+ if (xp)
+ xc++;
+ }
+ }
+
+ if (nans)
+ {
+ /* add x info */
+ int nxans = 0;
+ for (i = 0; i < xc; i++)
+ {
+ int type;
+ type = AsUINT16(xd[i]);
+ oldbp = bp;
+ if (type == DNS_TYPE_SRV)
+ bp = SLPMDNSAddRR(bp, obuf->start, oend, xn[i], 0, type, AsUINT32(xd[i] + 4), cvec, &ncvec, AsUINT16(xd[i] + 14), xd[i] + 16, 0);
+ else if (type == DNS_TYPE_TXT || type == DNS_TYPE_A)
+ bp = SLPMDNSAddRR(bp, obuf->start, oend, xn[i], 0, type, AsUINT32(xd[i] + 4), cvec, &ncvec, AsUINT16(xd[i] + 8), xd[i] + 10, 0);
+ else
+ continue;
+ if (!bp)
+ {
+ bp = oldbp;
+ break;
+ }
+ nxans++;
+ }
+ ToUINT16(obuf->start + 10, nxans);
+ obuf->end = bp;
+#ifdef DEBUG
+ SLPMDNSDumpDNS(obuf, "mdns outgoing");
+#endif
+ }
+ else
+ obuf->end = obuf->start;
+ return 0;
+}
+
+static int MDNSHandleARqst(SLPBuffer buf, SLPBuffer obuf, unsigned char *q, int qtype, unsigned char **an, unsigned char **ad, int ac, int mdnspeer, struct sockaddr_in *ifaddr)
+{
+ unsigned char *data, *bp, *oend;
+ unsigned char *cvec[256];
+ int i, ncvec;
+
+ data = (unsigned char *)&ifaddr->sin_addr;
+
+ obuf->start[0] = buf->start[0]; /* xid */
+ obuf->start[1] = buf->start[1]; /* xid */
+ obuf->start[2] = 0x84;
+ obuf->start[3] = 0x00;
+ obuf->start[4] = obuf->start[5] = 0; /* qcount */
+ obuf->start[6] = obuf->start[7] = 0; /* acount */
+ obuf->start[8] = obuf->start[9] = 0; /* ncount */
+ obuf->start[10] = obuf->start[11] = 0; /* xcount */
+
+ ncvec = 0;
+ bp = obuf->start + 12;
+ oend = obuf->start + obuf->allocated;
+ if (!mdnspeer)
+ {
+ bp = SLPMDNSCompN(bp, oend, q, buf->start, cvec, &ncvec, obuf->start);
+ if (!bp || bp + 4 >= oend)
+ return 1;
+ *bp++ = 0;
+ *bp++ = qtype;
+ *bp++ = 0;
+ *bp++ = DNS_CLASS_IN;
+ obuf->start[5] = 1;
+ }
+
+ for (i = 0; i < ac; i++)
+ if (AsUINT16(ad[i]) == DNS_TYPE_A &&
+ !memcmp(ad[i] + 10, data, 4))
+ break;
+ if (i < ac)
+ {
+ obuf->end = obuf->start;
+ return 0;
+ }
+
+ bp = SLPMDNSAddRR(bp, obuf->start, oend, q, buf->start, DNS_TYPE_A, 10, cvec, &ncvec, 4, data, 0);
+ if (!bp)
+ return 1;
+ obuf->start[7] = 1;
+ obuf->end = bp;
+#ifdef DEBUG
+ SLPMDNSDumpDNS(obuf, "mdns outgoing");
+#endif
+ return 0;
+}
--- ./slpd/slpd_mdns.h.orig 2006-11-16 16:19:30.000000000 +0000
+++ ./slpd/slpd_mdns.h 2006-11-16 16:19:30.000000000 +0000
@@ -0,0 +1,50 @@
+#ifndef SLPD_MDNS_H_INCLUDE
+#define SLPD_MDNS_H_INCLUDE
+
+#include "slpd.h"
+
+/*=========================================================================*/
+/* common code includes */
+/*=========================================================================*/
+#include "slp_linkedlist.h"
+#include "slp_mdns.h"
+
+
+/*=========================================================================*/
+extern SLPList G_MDNSSocketList;
+/*=========================================================================*/
+
+
+/*=========================================================================*/
+void SLPDMDNSHandler(int* fdcount,
+ fd_set* readfds,
+ fd_set* writefds);
+/* Handles all outgoing requests that are pending on the specified file */
+/* discriptors */
+/* */
+/* fdcount (IN/OUT) number of file descriptors marked in fd_sets */
+/* */
+/* readfds (IN) file descriptors with pending read IO */
+/* */
+/* writefds (IN) file descriptors with pending read IO */
+/*=========================================================================*/
+
+
+/*=========================================================================*/
+int SLPDMDNSInit(void);
+/* Initialize incoming socket list to have appropriate sockets for all */
+/* network interfaces */
+/* */
+/* Returns Zero on success non-zero on error */
+/*=========================================================================*/
+
+
+/*=========================================================================*/
+int SLPDMDNSDeinit(void);
+/* Deinitialize incoming socket list to have appropriate sockets for all */
+/* network interfaces */
+/* */
+/* Returns Zero on success non-zero on error */
+/*=========================================================================*/
+
+#endif
--- ./slpd/slpd_process.c.orig 2003-02-20 16:43:57.000000000 +0000
+++ ./slpd/slpd_process.c 2006-11-16 16:19:30.000000000 +0000
@@ -1331,11 +1331,14 @@ int SLPDProcessMessage(struct sockaddr_i
SLPDLogMessage(SLPDLOG_TRACEMSG_IN,peerinfo,recvbuf);
- /* set the sendbuf empty */
- if(*sendbuf)
+ if(!*sendbuf)
{
- (*sendbuf)->end = (*sendbuf)->start;
+ *sendbuf = SLPBufferAlloc(SLP_MAX_DATAGRAM_SIZE);
+ if (!*sendbuf)
+ return SLP_ERROR_PARSE_ERROR;
}
+ /* set the sendbuf empty */
+ (*sendbuf)->end = (*sendbuf)->start;
/* zero out the header before parsing it */
memset(&header,0,sizeof(header));
--- ./slpd/slpd_property.c.orig 2002-06-11 17:25:40.000000000 +0000
+++ ./slpd/slpd_property.c 2006-11-16 16:19:30.000000000 +0000
@@ -65,6 +65,7 @@
/*=========================================================================*/
SLPDProperty G_SlpdProperty;
+FILE* G_SlpdConffileFP;
/*=========================================================================*/
/*=========================================================================*/
@@ -74,8 +75,18 @@ int SLPDPropertyInit(const char* conffil
char* myname = 0;
char* myinterfaces = 0;
char* myurl = 0;
+ const char* ifaces = 0;
+ extern int * SLPPropertyReadFileFP(FILE *);
- SLPPropertyReadFile(conffile);
+ if (conffile)
+ {
+ G_SlpdConffileFP = fopen(conffile, "r");
+ if (G_SlpdConffileFP)
+ {
+ SLPPropertySet("net.slp.OpenSLPConfigFile",conffile);
+ }
+ }
+ SLPPropertyReadFileFP(G_SlpdConffileFP);
memset(&G_SlpdProperty,0,sizeof(G_SlpdProperty));
@@ -125,9 +136,14 @@ int SLPDPropertyInit(const char* conffil
/*-------------------------------------*/
/* Set the net.slp.interfaces property */
/*-------------------------------------*/
- if(SLPIfaceGetInfo(SLPPropertyGet("net.slp.interfaces"),&G_SlpdProperty.ifaceInfo) == 0)
+ ifaces = SLPPropertyGet("net.slp.interfaces");
+ if (!ifaces || !*ifaces)
{
- if(SLPPropertyGet("net.slp.interfaces"))
+ G_SlpdProperty.updateIfaces = 1;
+ }
+ if(SLPIfaceGetInfo(ifaces, &G_SlpdProperty.ifaceInfo) == 0)
+ {
+ if(ifaces)
{
if(SLPIfaceSockaddrsToString(G_SlpdProperty.ifaceInfo.iface_addr,
G_SlpdProperty.ifaceInfo.iface_count,
@@ -137,39 +153,73 @@ int SLPDPropertyInit(const char* conffil
{
SLPPropertySet("net.slp.interfaces", myinterfaces);
xfree(myinterfaces);
+ ifaces = SLPPropertyGet("net.slp.interfaces");
}
}
}
- G_SlpdProperty.interfaces = SLPPropertyGet("net.slp.interfaces");
}
- G_SlpdProperty.interfacesLen = strlen(G_SlpdProperty.interfaces);
-
+ else
+ {
+ G_SlpdProperty.ifaceInfo.iface_count = SLP_MAX_IFACES;
+ if (SLPIfaceStringToSockaddrs(ifaces, G_SlpdProperty.ifaceInfo.iface_addr, &G_SlpdProperty.ifaceInfo.iface_count) != 0)
+ {
+ G_SlpdProperty.ifaceInfo.iface_count = 0;
+ }
+ }
+ G_SlpdProperty.interfaces = ifaces;
+ G_SlpdProperty.interfacesLen = ifaces ? strlen(ifaces) : 0;
+ /*----------------------------*/
+ /* Get out canonical hostname */
+ /*----------------------------*/
+ if(SLPNetGetThisHostname(&myname,0) == 0)
+ {
+ if (!myname && !G_SlpdProperty.myHostnameLen)
+ myname = xstrdup("127.0.0.1");
+ if (myname)
+ {
+ SLPPropertySet("net.slp.myHostname",myname);
+ xfree(myname);
+ G_SlpdProperty.myHostname = SLPPropertyGet("net.slp.myHostname");
+ G_SlpdProperty.myHostnameLen = strlen(G_SlpdProperty.myHostname);
+ }
+ }
+
/*---------------------------------------------------------*/
/* Set the value used internally as the url for this agent */
/*---------------------------------------------------------*/
/* 27 is the size of "service:directory-agent://(NULL)" */
if(SLPNetGetThisHostname(&myname,1) == 0)
{
- myurl = (char*)xmalloc(27 + strlen(myname));
- if(G_SlpdProperty.isDA)
- {
- strcpy(myurl,SLP_DA_SERVICE_TYPE);
- }
- else
- {
- strcpy(myurl,SLP_SA_SERVICE_TYPE);
- }
- strcat(myurl,"://");
- strcat(myurl,myname);
-
- SLPPropertySet("net.slp.agentUrl",myurl);
+ if (!myname && !G_SlpdProperty.myUrlLen)
+ myname = xstrdup("127.0.0.1");
+ if (myname)
+ {
+ if (!strncmp(myname, "127.", 4))
+ {
+ /* cannot run as DA if hostname is loopback */
+ G_SlpdProperty.isDA = 0;
+ }
+ myurl = (char*)xmalloc(27 + strlen(myname));
+ if(G_SlpdProperty.isDA)
+ {
+ strcpy(myurl,SLP_DA_SERVICE_TYPE);
+ }
+ else
+ {
+ strcpy(myurl,SLP_SA_SERVICE_TYPE);
+ }
+ strcat(myurl,"://");
+ strcat(myurl,myname);
+
+ SLPPropertySet("net.slp.agentUrl",myurl);
- G_SlpdProperty.myUrl = SLPPropertyGet("net.slp.agentUrl");
- G_SlpdProperty.myUrlLen = strlen(G_SlpdProperty.myUrl);
+ G_SlpdProperty.myUrl = SLPPropertyGet("net.slp.agentUrl");
+ G_SlpdProperty.myUrlLen = strlen(G_SlpdProperty.myUrl);
- xfree(myurl);
- xfree(myname);
+ xfree(myurl);
+ xfree(myname);
+ }
}
/*----------------------------------*/
--- ./slpd/slpd_property.h.orig 2002-06-11 17:25:40.000000000 +0000
+++ ./slpd/slpd_property.h 2006-11-16 16:19:30.000000000 +0000
@@ -61,6 +61,8 @@ typedef struct _SLPDProperty
{
int myUrlLen;
const char* myUrl;
+ int myHostnameLen;
+ const char* myHostname;
int useScopesLen;
const char* useScopes;
int DAAddressesLen;
@@ -69,6 +71,7 @@ typedef struct _SLPDProperty
SLPIfaceInfo ifaceInfo;
int interfacesLen;
const char* interfaces;
+ int updateIfaces;
int localeLen;
const char* locale;
int isBroadcastOnly;
--- ./slpd/slpd_regfile.c.orig 2002-03-19 23:52:15.000000000 +0000
+++ ./slpd/slpd_regfile.c 2006-11-16 16:19:30.000000000 +0000
@@ -153,6 +153,7 @@ int SLPDRegFileReadSrvReg(FILE* fd,
{
char* slider1;
char* slider2;
+ char* p;
char line[4096];
struct sockaddr_in peer;
@@ -175,6 +176,8 @@ int SLPDRegFileReadSrvReg(FILE* fd,
unsigned char* attrauth = 0;
int attrauthlen = 0;
#endif
+ int watchport = 0;
+ int watchflags = 0;
/*-------------------------------------------*/
@@ -212,6 +215,17 @@ int SLPDRegFileReadSrvReg(FILE* fd,
result = SLP_ERROR_INTERNAL_ERROR;
goto CLEANUP;
}
+
+ /* replace "$HOSTNAME" string in url */
+ while ((p = strchr(url, '$')) && !strncmp(p, "$HOSTNAME", 9))
+ {
+ char *_url = (char*)malloc(strlen(url) - 9 + G_SlpdProperty.myHostnameLen + 1);
+ strncpy(_url, url, p - url);
+ strncpy(_url + (p - url), G_SlpdProperty.myHostname, G_SlpdProperty.myHostnameLen);
+ strcpy(_url + (p - url) + G_SlpdProperty.myHostnameLen, url + (p - url) + 9);
+ free(url);
+ url = _url;
+ }
urllen = strlen(url);
/* derive srvtype from srvurl */
@@ -349,6 +363,22 @@ int SLPDRegFileReadSrvReg(FILE* fd,
}
}
}
+ else if(strncasecmp(slider1,"tcp-port",8) == 0 || strncasecmp(slider1,"watch-port-tcp",14) == 0)
+ {
+ slider2 = strchr(slider1,'=');
+ if (slider2) {
+ watchport = atoi(slider2 + 1);
+ watchflags |= SLP_REG_WATCH_TCP;
+ }
+ }
+ else if(strncasecmp(slider1,"watch-port-udp",14) == 0)
+ {
+ slider2 = strchr(slider1,'=');
+ if (slider2) {
+ watchport = atoi(slider2 + 1);
+ watchflags |= SLP_REG_WATCH_UDP;
+ }
+ }
else
{
/* line contains an attribute (slow but it works)*/
@@ -554,6 +584,8 @@ int SLPDRegFileReadSrvReg(FILE* fd,
peer.sin_addr.s_addr = htonl(LOOPBACK_ADDRESS);
result = SLPMessageParseBuffer(&peer,*buf,*msg);
(*msg)->body.srvreg.source = SLP_REG_SOURCE_STATIC;
+ (*msg)->body.srvreg.watchflags = watchflags ? (watchflags | SLP_REG_WATCH_DEAD) : 0;
+ (*msg)->body.srvreg.watchport = watchport;
CLEANUP:
--- ./slpd/slpd_socket.c.orig 2006-11-16 16:19:17.000000000 +0000
+++ ./slpd/slpd_socket.c 2006-11-16 16:19:30.000000000 +0000
@@ -412,6 +412,8 @@ SLPDSocket* SLPDSocketCreateBoundDatagra
sock->fd = socket(PF_INET, SOCK_DGRAM, 0);
if(sock->fd >=0)
{
+ if(myaddr != NULL)
+ sock->ifaddr.sin_addr = *myaddr;
if(BindSocketToInetAddr(sock->fd, bindaddr) == 0)
{
if(peeraddr != NULL)
@@ -479,6 +481,8 @@ SLPDSocket* SLPDSocketCreateListen(struc
sock->fd = socket(PF_INET, SOCK_STREAM, 0);
if(sock->fd >= 0)
{
+ if(peeraddr != NULL)
+ sock->ifaddr.sin_addr = *peeraddr;
if(BindSocketToInetAddr(sock->fd, peeraddr) >= 0)
{
if(listen(sock->fd,5) == 0)
--- ./slpd/slpd_socket.h.orig 2002-12-03 21:04:54.000000000 +0000
+++ ./slpd/slpd_socket.h 2006-11-16 16:19:30.000000000 +0000
@@ -97,6 +97,7 @@ typedef struct _SLPDSocket
int fd;
time_t age; /* in seconds */
int state;
+ struct sockaddr_in ifaddr; /* address of interface */
struct sockaddr_in peeraddr;
/* Incoming socket stuff */
--- ./slpd/slpd_spi.c.orig 2001-04-16 22:17:31.000000000 +0000
+++ ./slpd/slpd_spi.c 2006-11-16 16:19:30.000000000 +0000
@@ -68,6 +68,8 @@ int SLPDSpiInit(const char* spifile)
}
G_SlpdSpiHandle = SLPSpiOpen(spifile,1);
+ if (G_SlpdSpiHandle)
+ SLPSpiFill(G_SlpdSpiHandle);
return (G_SlpdSpiHandle == 0);
}
--- ./slptool/slptool.c.orig 2003-04-21 11:19:19.000000000 +0000
+++ ./slptool/slptool.c 2006-11-16 16:47:44.000000000 +0000
@@ -329,6 +329,20 @@ SLPBoolean mySrvUrlCallback( SLPHandle h
{
if(errcode == SLP_OK)
{
+ SLPToolCommandLine* cmdline = cookie;
+ if (cmdline->peerinfo)
+ {
+ char *peer = SLPGetPeer(hslp, srvurl);
+ if (peer)
+ {
+ printf("%s\t", peer);
+ SLPFree(peer);
+ }
+ else
+ {
+ printf("?\t");
+ }
+ }
printf("%s,%i\n",srvurl,lifetime);
}
@@ -350,7 +364,7 @@ void FindSrvs(SLPToolCommandLine* cmdlin
cmdline->scopes,
cmdline->cmdparam2,
mySrvUrlCallback,
- 0);
+ cmdline);
if(result != SLP_OK)
{
printf("errorcode: %i\n",result);
@@ -382,7 +396,7 @@ void FindSrvsUsingIFList(SLPToolCommandL
cmdline->scopes,
cmdline->cmdparam2,
mySrvUrlCallback,
- 0);
+ cmdline);
if(result != SLP_OK)
{
printf("errorcode: %i\n",result);
@@ -414,7 +428,7 @@ void UnicastFindSrvs(SLPToolCommandLine*
cmdline->scopes,
cmdline->cmdparam2,
mySrvUrlCallback,
- 0);
+ cmdline);
if(result != SLP_OK)
{
printf("errorcode: %i\n",result);
@@ -599,6 +613,11 @@ int ParseCommandLine(int argc,char* argv
return 1;
}
}
+ else if( strcasecmp(argv[i],"-p") == 0 ||
+ strcasecmp(argv[i],"--peerinfo") == 0 )
+ {
+ cmdline->peerinfo = SLP_TRUE;
+ }
else if(strcasecmp(argv[i],"findsrvs") == 0)
{
cmdline->cmd = FINDSRVS;
--- ./slptool/slptool.h.orig 2003-04-21 11:17:58.000000000 +0000
+++ ./slptool/slptool.h 2006-11-16 16:19:30.000000000 +0000
@@ -40,6 +40,8 @@
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
/*=========================================================================*/
typedef enum _SLPToolCommand
@@ -78,6 +80,7 @@ typedef struct _SLPToolCommandLine
const char* cmdparam1;
const char* cmdparam2;
const char* cmdparam3;
+ SLPBoolean peerinfo;
}SLPToolCommandLine;
Reference in New Issue View Git Blame Copy Permalink