static void
resolve_reply (DNSServiceRef client,
DNSServiceFlags flags,
uint32_t ifIndex,
DNSServiceErrorType errorCode,
const char *fullname,
const char *hosttarget,
uint16_t opaqueport,
uint16_t txtLen,
const char *txtRecord,
void *context)
{
GMDNSUserData *ud = context;
GMDNSUserData *ud2;
DNSServiceErrorType err;
gint i;
union { guint16 s; guchar b[2]; } portu = { opaqueport };
g_return_if_fail (ud);
ud->server->port = ((guint16) portu.b[0]) << 8 | portu.b[1];
ud->server->hostname = g_strdup (hosttarget);
ud->server->txtvalues = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, g_free);
for (i = 0; i < TXTRecordGetCount (txtLen, txtRecord); i++) {
gchar key[256];
const void *txt_value;
gchar *value;
guint8 vallen;
err = TXTRecordGetItemAtIndex (txtLen, txtRecord, i, 256, key, &vallen, &txt_value);
if (err != kDNSServiceErr_NoError) {
g_warning ("error parsing TXT records!");
}
value = g_malloc (vallen + 1);
g_strlcpy (value, txt_value, vallen + 1);
g_hash_table_insert (ud->server->txtvalues, g_strdup (key), value);
}
ud2 = g_new0 (GMDNSUserData, 1);
err = DNSServiceQueryRecord (&ud2->client, 0,
kDNSServiceInterfaceIndexAny,
ud->server->hostname,
kDNSServiceType_A,
kDNSServiceClass_IN,
qr_reply, ud2);
if (err != kDNSServiceErr_NoError) {
g_warning ("Error from QueryRecord!");
}
g_mdns_poll_add (ud->mdns, ud2, ud2->client);
ud2->server = ud->server;
g_mdns_user_data_destroy (ud);
}
STDMETHODIMP CTXTRecord::GetCount(ULONG* count)
{
*count = 0;
if ( m_byteArray.size() > 0 )
{
*count = TXTRecordGetCount( ( uint16_t ) m_byteArray.size(), &m_byteArray[ 0 ] );
}
return S_OK;
}
void DNSSD_API CZeroconfBrowserMDNS::ResolveCallback(DNSServiceRef sdRef,
DNSServiceFlags flags,
uint32_t interfaceIndex,
DNSServiceErrorType errorCode,
const char *fullname,
const char *hosttarget,
uint16_t port, /* In network byte order */
uint16_t txtLen,
const unsigned char *txtRecord,
void *context
)
{
if (errorCode)
{
CLog::Log(LOGERROR, "ZeroconfBrowserMDNS: ResolveCallback failed with error = %ld", (int) errorCode);
return;
}
DNSServiceErrorType err;
CZeroconfBrowser::ZeroconfService::tTxtRecordMap recordMap;
CStdString strIP;
CZeroconfBrowserMDNS* p_instance = static_cast<CZeroconfBrowserMDNS*> ( context );
if(!CDNSNameCache::Lookup(hosttarget, strIP))
{
CLog::Log(LOGERROR, "ZeroconfBrowserMDNS: Could not resolve hostname %s",hosttarget);
p_instance->m_resolved_event.Set();
return;
}
p_instance->m_resolving_service.SetIP(strIP);
for(uint16_t i = 0; i < TXTRecordGetCount(txtLen, txtRecord); ++i)
{
char key[256];
uint8_t valueLen;
const void *value;
std::string strvalue;
err = TXTRecordGetItemAtIndex(txtLen, txtRecord,i ,sizeof(key) , key, &valueLen, &value);
if(err != kDNSServiceErr_NoError)
continue;
if(value != NULL && valueLen > 0)
strvalue.append((const char *)value, valueLen);
recordMap.insert(std::make_pair(key, strvalue));
}
p_instance->m_resolving_service.SetTxtRecords(recordMap);
p_instance->m_resolving_service.SetPort(ntohs(port));
p_instance->m_resolved_event.Set();
}
static void
_ptpip_resolved (
DNSServiceRef sdRef, DNSServiceFlags flags, uint32_t interfaceIndex,
DNSServiceErrorType errorCode,
const char *fullname, const char *hosttarget, uint16_t port,
uint16_t txtLen, const char *txtRecord, void *context
) {
struct hostent* hent;
struct in_addr inaddr;
GPPortInfo *info;
int i, cnt;
struct mdnsinfo *mdnsi = context;
char path[200];
if (errorCode != kDNSServiceErr_NoError) {
gp_log (GP_LOG_ERROR, "ptpip", "Error on 2nd level query.");
return;
}
gp_log (GP_LOG_DEBUG, "ptpip", "fullname %s, hosttarget %s, port %d", fullname, hosttarget, htons(port));
cnt = TXTRecordGetCount (txtLen, txtRecord);
for (i=0;i<cnt;i++) {
char key[256];
uint8_t valuelen;
const void *value;
valuelen = 0;
if (kDNSServiceErr_NoError == TXTRecordGetItemAtIndex (txtLen, txtRecord, i, sizeof(key), key, &valuelen, &value))
gp_log (GP_LOG_DEBUG, "ptpip", "%d: %s:%s", i, key, (char*)value);
}
hent = gethostbyname (hosttarget);
if (!hent) {
gp_log (GP_LOG_ERROR, "ptpip", "Could not resolve the returned host: %s", hosttarget);
return;
}
memcpy(&inaddr.s_addr,hent->h_addr_list[0],hent->h_length);
gp_port_info_new (&info);
gp_port_info_set_type (info, GP_PORT_PTPIP);
gp_port_info_set_name (info, mdnsi->name);
snprintf (path, sizeof(path), "ptpip:%s:%d", inet_ntoa(inaddr), htons(port));
gp_port_info_set_path (info, path);
gp_port_info_list_append (mdnsi->list, info);
}
void
ResolveOperator::Reply(DNSServiceRef aSdRef,
DNSServiceFlags aFlags,
uint32_t aInterfaceIndex,
DNSServiceErrorType aErrorCode,
const nsACString& aFullName,
const nsACString& aHostTarget,
uint16_t aPort,
uint16_t aTxtLen,
const unsigned char* aTxtRecord)
{
MOZ_ASSERT(GetThread() == NS_GetCurrentThread());
mDeleteProtector = nullptr;
if (NS_WARN_IF(kDNSServiceErr_NoError != aErrorCode)) {
LOG_E("ResolveOperator::Reply (%d)", aErrorCode);
return;
}
// Resolve TXT record
int count = TXTRecordGetCount(aTxtLen, aTxtRecord);
LOG_I("resolve: txt count = %d, len = %d", count, aTxtLen);
nsCOMPtr<nsIWritablePropertyBag2> attributes = nullptr;
if (count) {
attributes = new nsHashPropertyBag();
if (NS_WARN_IF(!attributes)) { return; }
for (int i = 0; i < count; ++i) {
char key[TXT_BUFFER_SIZE] = { '\0' };
uint8_t vSize = 0;
const void* value = nullptr;
if (kDNSServiceErr_NoError !=
TXTRecordGetItemAtIndex(aTxtLen,
aTxtRecord,
i,
TXT_BUFFER_SIZE,
key,
&vSize,
&value)) {
break;
}
nsAutoCString str(reinterpret_cast<const char*>(value), vSize);
LOG_I("resolve TXT: (%d) %s=%s", vSize, key, str.get());
if (NS_WARN_IF(NS_FAILED(attributes->SetPropertyAsACString(
/* it's safe to convert because key name is ASCII only. */
NS_ConvertASCIItoUTF16(key),
str)))) {
break;
}
}
}
if (!mListener) { return; }
nsCOMPtr<nsIDNSServiceInfo> info = new nsDNSServiceInfo(mServiceInfo);
if (NS_WARN_IF(NS_FAILED(info->SetHost(aHostTarget)))) { return; }
if (NS_WARN_IF(NS_FAILED(info->SetPort(aPort)))) { return; }
if (NS_WARN_IF(NS_FAILED(info->SetAttributes(attributes)))) { return; }
if (kDNSServiceErr_NoError == aErrorCode) {
GetAddrInfor(info);
}
else {
mListener->OnResolveFailed(info, aErrorCode);
NS_WARN_IF(NS_FAILED(Stop()));
}
}
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char *argv[]) {
const char *r;
TXTRecordRef ref;
uint8_t l;
const void *p;
char k[256];
TXTRecordCreate(&ref, 0, NULL);
hexdump(TXTRecordGetBytesPtr(&ref), TXTRecordGetLength(&ref));
TXTRecordSetValue(&ref, "foo", 7, "lennart");
hexdump(TXTRecordGetBytesPtr(&ref), TXTRecordGetLength(&ref));
TXTRecordSetValue(&ref, "waldo", 5, "rocks");
hexdump(TXTRecordGetBytesPtr(&ref), TXTRecordGetLength(&ref));
TXTRecordSetValue(&ref, "quux", 9, "the_house");
hexdump(TXTRecordGetBytesPtr(&ref), TXTRecordGetLength(&ref));
TXTRecordSetValue(&ref, "yeah", 0, NULL);
hexdump(TXTRecordGetBytesPtr(&ref), TXTRecordGetLength(&ref));
TXTRecordSetValue(&ref, "waldo", 6, "rocked");
hexdump(TXTRecordGetBytesPtr(&ref), TXTRecordGetLength(&ref));
TXTRecordRemoveValue(&ref, "foo");
hexdump(TXTRecordGetBytesPtr(&ref), TXTRecordGetLength(&ref));
TXTRecordRemoveValue(&ref, "waldo");
hexdump(TXTRecordGetBytesPtr(&ref), TXTRecordGetLength(&ref));
TXTRecordSetValue(&ref, "kawumm", 6, "bloerb");
hexdump(TXTRecordGetBytesPtr(&ref), TXTRecordGetLength(&ref));
TXTRecordSetValue(&ref, "one", 1, "1");
hexdump(TXTRecordGetBytesPtr(&ref), TXTRecordGetLength(&ref));
TXTRecordSetValue(&ref, "two", 1, "2");
hexdump(TXTRecordGetBytesPtr(&ref), TXTRecordGetLength(&ref));
TXTRecordSetValue(&ref, "three", 1, "3");
hexdump(TXTRecordGetBytesPtr(&ref), TXTRecordGetLength(&ref));
assert(TXTRecordContainsKey(TXTRecordGetLength(&ref), TXTRecordGetBytesPtr(&ref), "two"));
assert(!TXTRecordContainsKey(TXTRecordGetLength(&ref), TXTRecordGetBytesPtr(&ref), "four"));
r = TXTRecordGetValuePtr(TXTRecordGetLength(&ref), TXTRecordGetBytesPtr(&ref), "kawumm", &l);
hexdump(r, l);
assert(TXTRecordGetCount(TXTRecordGetLength(&ref), TXTRecordGetBytesPtr(&ref)) == 6);
TXTRecordGetItemAtIndex(TXTRecordGetLength(&ref), TXTRecordGetBytesPtr(&ref), 2, sizeof(k), k, &l, &p);
fprintf(stderr, "key=<%s>\n", k);
hexdump(p, l);
assert(TXTRecordGetItemAtIndex(TXTRecordGetLength(&ref), TXTRecordGetBytesPtr(&ref), 20, sizeof(k), k, &l, &p) == kDNSServiceErr_Invalid);
TXTRecordDeallocate(&ref);
}
void DNSSD_API CZeroconfBrowserWIN::ResolveCallback(DNSServiceRef sdRef,
DNSServiceFlags flags,
uint32_t interfaceIndex,
DNSServiceErrorType errorCode,
const char *fullname,
const char *hosttarget,
uint16_t port, /* In network byte order */
uint16_t txtLen,
const unsigned char *txtRecord,
void *context
)
{
if (errorCode)
{
CLog::Log(LOGERROR, "ZeroconfBrowserWIN: ResolveCallback failed with error = %ld", (int) errorCode);
return;
}
DNSServiceErrorType err;
CZeroconfBrowser::ZeroconfService::tTxtRecordMap recordMap;
CStdString strIP;
CZeroconfBrowser::ZeroconfService* service = (CZeroconfBrowser::ZeroconfService*) context;
#if defined(__VIDONME_MEDIACENTER__)
{
DNSServiceErrorType err;
DNSServiceRef sdRef = NULL;
err = DNSServiceGetAddrInfo(&sdRef, kDNSServiceFlagsReturnIntermediates, kDNSServiceInterfaceIndexAny,kDNSServiceProtocol_IPv4, hosttarget, AddrinfoCallback, service);
if( err != kDNSServiceErr_NoError )
{
if (sdRef)
DNSServiceRefDeallocate(sdRef);
CLog::Log(LOGERROR, "ZeroconfBrowserWIN: DNSServiceGetAddrInfo returned (error = %ld)", (int) err);
return;
}
err = DNSServiceProcessResult(sdRef);
if (err != kDNSServiceErr_NoError)
CLog::Log(LOGERROR, "ZeroconfBrowserWIN::doGetAddrInfoService DNSServiceProcessResult returned (error = %ld)", (int) err);
if (sdRef)
DNSServiceRefDeallocate(sdRef);
}
#else
if(!CDNSNameCache::Lookup(hosttarget, strIP))
{
CLog::Log(LOGERROR, "ZeroconfBrowserWIN: Could not resolve hostname %s",hosttarget);
return;
}
service->SetIP(strIP);
#endif
for(uint16_t i = 0; i < TXTRecordGetCount(txtLen, txtRecord); ++i)
{
char key[256];
uint8_t valueLen;
const void *value;
std::string strvalue;
err = TXTRecordGetItemAtIndex(txtLen, txtRecord,i ,sizeof(key) , key, &valueLen, &value);
if(err != kDNSServiceErr_NoError)
continue;
if(value != NULL && valueLen > 0)
strvalue.append((const char *)value, valueLen);
recordMap.insert(std::make_pair(key, strvalue));
}
service->SetTxtRecords(recordMap);
service->SetPort(ntohs(port));
}
