This file is indexed.

/usr/include/dnssd/remoteservice.h is in kdelibs5-dev 4:4.14.16-0ubuntu3.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
/* This file is part of the KDE project
 *
 * Copyright (C) 2004, 2005 Jakub Stachowski <qbast@go2.pl>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */

#ifndef DNSSDREMOTESERVICE_H
#define DNSSDREMOTESERVICE_H

#include <QtCore/QObject>
#include <QtCore/QMetaType>
#include <dnssd/servicebase.h>

namespace DNSSD
{
class RemoteServicePrivate;

/**
 * @class RemoteService remoteservice.h DNSSD/RemoteService
 * @short Describes a service published over DNS-SD,
 *        typically on a remote machine
 *
 * This class allows delayed or asynchronous resolution of
 * services.  As the name suggests, the service is normally
 * on a remote machine, but the service could just as easily
 * be published on the local machine.
 *
 * RemoteService instances are normally provided by ServiceBrowser,
 * but can be used to resolve any service if you know the name, type
 * and domain for it.
 *
 * @author Jakub Stachowski
 *
 * @see ServiceBrowser
 */
class KDNSSD_EXPORT RemoteService : public QObject, public ServiceBase
{
	Q_OBJECT

public:
	typedef KSharedPtr<RemoteService> Ptr;

	/**
	 * Creates an unresolved RemoteService representing the service with
	 * the given name, type and domain
	 *
	 * @param name   the name of the service
	 * @param type   the type of the service (see ServiceBrowser::ServiceBrowser())
	 * @param domain the domain of the service
	 *
	 * @see ServiceBrowser::isAvailable()
	 */
	RemoteService(const QString& name, const QString& type, const QString& domain);

	virtual ~RemoteService();

	/**
	 * Resolves the host name and port of service asynchronously
	 *
	 * The host name is not resolved into an IP address - use KResolver
	 * for that.
	 *
	 * The resolved(bool) signal will be emitted when the
	 * resolution is complete, or when it fails.
	 *
	 * Note that resolved(bool) may be emitted before this function
	 * returns in case of immediate failure.
	 *
	 * RemoteService will keep monitoring the service for
	 * changes in hostname and port, and re-emit resolved(bool)
	 * when either changes.
	 *
	 * @see resolve(), hostName(), port()
	 */
	void resolveAsync();

	/**
	 * Resolves the host name and port of service synchronously
	 *
	 * The host name is not resolved into an IP address - use KResolver
	 * for that.
	 *
	 * resolved(bool) is emitted before this function is returned.
	 *
	 * resolve() will not cause RemoteService to monitor for changes
	 * in the hostname or port of the service.
	 *
	 * @return @c true if successful, @c false on failure
	 *
	 * @see resolveAsync(), hostName(), port()
	 */
	bool resolve();

	/**
	 * Whether the service has been successfully resolved
	 *
	 * @return @c true if hostName() and port() will return
	 *         valid values, @c false otherwise
	 */
	bool isResolved() const;

Q_SIGNALS:
	/**
	 * Emitted when resolving is complete
	 *
	 * If operating in asynchronous mode this signal can be
	 * emitted several times (when the hostName or port of
	 * the service changes).
	 *
	 * @param successful @c true if the hostName and port were
	 *                   successfully resolved, @c false otherwise
	 */
	void resolved(bool successful);

protected:
	virtual void virtual_hook(int id, void *data);
private:
	friend class RemoteServicePrivate;

};

}

Q_DECLARE_METATYPE(DNSSD::RemoteService::Ptr)

#endif