void resolve_callback ( DNSServiceRef,
DNSServiceFlags,
uint32_t,
DNSServiceErrorType errorCode,
const char*,
const char *hosttarget,
uint16_t port,
uint16_t txtLen,
const unsigned char *txtRecord,
void *context
)
{
QObject *obj = reinterpret_cast<QObject*>(context);
if (errorCode != kDNSServiceErr_NoError) {
ErrorEvent err;
QCoreApplication::sendEvent(obj, &err);
return;
}
char key[256];
int index=0;
unsigned char valueLen;
kDebug() << "Resolve callback\n";
QMap<QString,QByteArray> map;
const void *voidValue = 0;
while (TXTRecordGetItemAtIndex(txtLen,txtRecord,index++,256,key,&valueLen,
&voidValue) == kDNSServiceErr_NoError)
{
if (voidValue) map[QString::fromUtf8(key)]=QByteArray((const char*)voidValue,valueLen);
else map[QString::fromUtf8(key)].clear();
}
ResolveEvent rev(DNSToDomain(hosttarget),ntohs(port),map);
QCoreApplication::sendEvent(obj, &rev);
}
void resolveCB_( DNSServiceErrorType error, const char* name,
const char* host, uint16_t txtLen,
const unsigned char* txt )
{
if( error != kDNSServiceErr_NoError)
{
LBWARN << "Resolve callback error: " << error << std::endl;
return;
}
ValueMap& values = instanceMap_[ browsedName_ ];
values[ "servus_host" ] = host;
char key[256] = {0};
const char* value = 0;
uint8_t valueLen = 0;
uint16_t i = 0;
while( TXTRecordGetItemAtIndex( txtLen, txt, i, sizeof( key ), key,
&valueLen, (const void**)( &value )) ==
kDNSServiceErr_NoError )
{
values[ key ] = std::string( value, valueLen );
++i;
//LBINFO << browsedName_ << key << "=" << values[ key ] << std::endl;
}
}
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);
}
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 int
mdns_addr_lookup_start(struct mdns_resolver *rs, uint32_t interfaceIndex,
const char *hosttarget, uint16_t port, uint16_t txtLen,
const unsigned char *txtRecord)
{
struct mdns_addr_lookup *lu;
DNSServiceErrorType err;
char key[256];
int i;
uint8_t valueLen;
const char *value;
int ret;
lu = calloc(1, sizeof(*lu));
if (!lu)
{
DPRINTF(E_LOG, L_MDNS, "Out of memory creating address lookup.\n");
return -1;
}
lu->port = port;
lu->rs = rs;
for (i=0; TXTRecordGetItemAtIndex(txtLen, txtRecord, i, sizeof(key),
key, &valueLen, (const void **)&value)
!= kDNSServiceErr_Invalid; i++)
{
ret = keyval_add_size(&lu->txt_kv, key, value, valueLen);
if (ret < 0)
{
DPRINTF(E_LOG, L_MDNS, "Could not build TXT record keyval\n");
return mdns_addr_lookup_free(lu);
}
}
lu->sdref = mdns_sdref_main;
err = DNSServiceGetAddrInfo(&lu->sdref, kDNSServiceFlagsShareConnection,
interfaceIndex, rs->mb->protocol, hosttarget,
mdns_lookup_callback, lu);
if (err != kDNSServiceErr_NoError)
{
DPRINTF(E_LOG, L_MDNS, "Failed to create service resolver.\n");
lu->sdref = NULL;
return mdns_addr_lookup_free(lu);
}
/* resolver now owns the lookup */
lu->next = rs->lookups;
rs->lookups = lu;
return 0;
}
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);
}
STDMETHODIMP CTXTRecord::GetValueAtIndex(ULONG index, VARIANT* retval)
{
char keyBuf[ 64 ];
uint8_t rawValueLen;
const void * rawValue;
CComBSTR temp;
DNSServiceErrorType err;
BOOL ok;
HRESULT hr = S_OK;
err = TXTRecordGetItemAtIndex( ( uint16_t ) m_byteArray.size(), &m_byteArray[ 0 ], ( uint16_t ) index, sizeof( keyBuf ), keyBuf, &rawValueLen, &rawValue );
require_action( !err, exit, hr = S_FALSE );
ok = ByteArrayToVariant( rawValue, rawValueLen, retval );
require_action( ok, exit, hr = S_FALSE );
exit:
return hr;
}
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));
}