|
|
/* -*- Mode: C; tab-width: 4 -*-
|
|
|
*
|
|
|
* Copyright (c) 2002-2004 Apple Computer, Inc. All rights reserved.
|
|
|
*
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
* You may obtain a copy of the License at
|
|
|
*
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
*
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
* See the License for the specific language governing permissions and
|
|
|
* limitations under the License.
|
|
|
*/
|
|
|
|
|
|
#if __APPLE__
|
|
|
// In Mac OS X 10.5 and later trying to use the daemon function gives a “‘daemon’ is deprecated”
|
|
|
// error, which prevents compilation because we build with "-Werror".
|
|
|
// Since this is supposed to be portable cross-platform code, we don't care that daemon is
|
|
|
// deprecated on Mac OS X 10.5, so we use this preprocessor trick to eliminate the error message.
|
|
|
#define daemon yes_we_know_that_daemon_is_deprecated_in_os_x_10_5_thankyou
|
|
|
#endif
|
|
|
|
|
|
#include <assert.h>
|
|
|
#include <stdio.h> // For printf()
|
|
|
#include <stdlib.h> // For exit() etc.
|
|
|
#include <string.h> // For strlen() etc.
|
|
|
#include <unistd.h> // For select()
|
|
|
#include <errno.h> // For errno, EINTR
|
|
|
#include <signal.h>
|
|
|
#include <fcntl.h>
|
|
|
|
|
|
#if __APPLE__
|
|
|
#undef daemon
|
|
|
extern int daemon(int, int);
|
|
|
#endif
|
|
|
|
|
|
#include "mDNSEmbeddedAPI.h"// Defines the interface to the client layer above
|
|
|
#include "mDNSPosix.h" // Defines the specific types needed to run mDNS on this platform
|
|
|
#include "mDNSUNP.h" // For daemon()
|
|
|
|
|
|
#if COMPILER_LIKES_PRAGMA_MARK
|
|
|
#pragma mark ***** Globals
|
|
|
#endif
|
|
|
|
|
|
static mDNS mDNSStorage; // mDNS core uses this to store its globals
|
|
|
static mDNS_PlatformSupport PlatformStorage; // Stores this platform's globals
|
|
|
|
|
|
mDNSexport const char ProgramName[] = "mDNSResponderPosix";
|
|
|
|
|
|
static const char *gProgramName = ProgramName;
|
|
|
|
|
|
#if COMPILER_LIKES_PRAGMA_MARK
|
|
|
#pragma mark ***** Signals
|
|
|
#endif
|
|
|
|
|
|
static volatile mDNSBool gReceivedSigUsr1;
|
|
|
static volatile mDNSBool gReceivedSigHup;
|
|
|
static volatile mDNSBool gStopNow;
|
|
|
|
|
|
// We support 4 signals.
|
|
|
//
|
|
|
// o SIGUSR1 toggles verbose mode on and off in debug builds
|
|
|
// o SIGHUP triggers the program to re-read its preferences.
|
|
|
// o SIGINT causes an orderly shutdown of the program.
|
|
|
// o SIGQUIT causes a somewhat orderly shutdown (direct but dangerous)
|
|
|
// o SIGKILL kills us dead (easy to implement :-)
|
|
|
//
|
|
|
// There are fatal race conditions in our signal handling, but there's not much
|
|
|
// we can do about them while remaining within the Posix space. Specifically,
|
|
|
// if a signal arrives after we test the globals its sets but before we call
|
|
|
// select, the signal will be dropped. The user will have to send the signal
|
|
|
// again. Unfortunately, Posix does not have a "sigselect" to atomically
|
|
|
// modify the signal mask and start a select.
|
|
|
|
|
|
static void HandleSigUsr1(int sigraised)
|
|
|
// If we get a SIGUSR1 we toggle the state of the
|
|
|
// verbose mode.
|
|
|
{
|
|
|
assert(sigraised == SIGUSR1);
|
|
|
gReceivedSigUsr1 = mDNStrue;
|
|
|
}
|
|
|
|
|
|
static void HandleSigHup(int sigraised)
|
|
|
// A handler for SIGHUP that causes us to break out of the
|
|
|
// main event loop when the user kill 1's us. This has the
|
|
|
// effect of triggered the main loop to deregister the
|
|
|
// current services and re-read the preferences.
|
|
|
{
|
|
|
assert(sigraised == SIGHUP);
|
|
|
gReceivedSigHup = mDNStrue;
|
|
|
}
|
|
|
|
|
|
static void HandleSigInt(int sigraised)
|
|
|
// A handler for SIGINT that causes us to break out of the
|
|
|
// main event loop when the user types ^C. This has the
|
|
|
// effect of quitting the program.
|
|
|
{
|
|
|
assert(sigraised == SIGINT);
|
|
|
|
|
|
if (gMDNSPlatformPosixVerboseLevel > 0) {
|
|
|
fprintf(stderr, "\nSIGINT\n");
|
|
|
}
|
|
|
gStopNow = mDNStrue;
|
|
|
}
|
|
|
|
|
|
static void HandleSigQuit(int sigraised)
|
|
|
// If we get a SIGQUIT the user is desperate and we
|
|
|
// just call mDNS_Close directly. This is definitely
|
|
|
// not safe (because it could reenter mDNS), but
|
|
|
// we presume that the user has already tried the safe
|
|
|
// alternatives.
|
|
|
{
|
|
|
assert(sigraised == SIGQUIT);
|
|
|
|
|
|
if (gMDNSPlatformPosixVerboseLevel > 0) {
|
|
|
fprintf(stderr, "\nSIGQUIT\n");
|
|
|
}
|
|
|
mDNS_Close(&mDNSStorage);
|
|
|
exit(0);
|
|
|
}
|
|
|
|
|
|
#if COMPILER_LIKES_PRAGMA_MARK
|
|
|
#pragma mark ***** Parameter Checking
|
|
|
#endif
|
|
|
|
|
|
static mDNSBool CheckThatRichTextNameIsUsable(const char *richTextName, mDNSBool printExplanation)
|
|
|
// Checks that richTextName is reasonable
|
|
|
// label and, if it isn't and printExplanation is true, prints
|
|
|
// an explanation of why not.
|
|
|
{
|
|
|
mDNSBool result = mDNStrue;
|
|
|
if (result && strlen(richTextName) > 63) {
|
|
|
if (printExplanation) {
|
|
|
fprintf(stderr,
|
|
|
"%s: Service name is too long (must be 63 characters or less)\n",
|
|
|
gProgramName);
|
|
|
}
|
|
|
result = mDNSfalse;
|
|
|
}
|
|
|
if (result && richTextName[0] == 0) {
|
|
|
if (printExplanation) {
|
|
|
fprintf(stderr, "%s: Service name can't be empty\n", gProgramName);
|
|
|
}
|
|
|
result = mDNSfalse;
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
static mDNSBool CheckThatServiceTypeIsUsable(const char *serviceType, mDNSBool printExplanation)
|
|
|
// Checks that serviceType is a reasonable service type
|
|
|
// label and, if it isn't and printExplanation is true, prints
|
|
|
// an explanation of why not.
|
|
|
{
|
|
|
mDNSBool result;
|
|
|
|
|
|
result = mDNStrue;
|
|
|
if (result && strlen(serviceType) > 63) {
|
|
|
if (printExplanation) {
|
|
|
fprintf(stderr,
|
|
|
"%s: Service type is too long (must be 63 characters or less)\n",
|
|
|
gProgramName);
|
|
|
}
|
|
|
result = mDNSfalse;
|
|
|
}
|
|
|
if (result && serviceType[0] == 0) {
|
|
|
if (printExplanation) {
|
|
|
fprintf(stderr,
|
|
|
"%s: Service type can't be empty\n",
|
|
|
gProgramName);
|
|
|
}
|
|
|
result = mDNSfalse;
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
static mDNSBool CheckThatPortNumberIsUsable(long portNumber, mDNSBool printExplanation)
|
|
|
// Checks that portNumber is a reasonable port number
|
|
|
// and, if it isn't and printExplanation is true, prints
|
|
|
// an explanation of why not.
|
|
|
{
|
|
|
mDNSBool result;
|
|
|
|
|
|
result = mDNStrue;
|
|
|
if (result && (portNumber <= 0 || portNumber > 65535)) {
|
|
|
if (printExplanation) {
|
|
|
fprintf(stderr,
|
|
|
"%s: Port number specified by -p must be in range 1..65535\n",
|
|
|
gProgramName);
|
|
|
}
|
|
|
result = mDNSfalse;
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
#if COMPILER_LIKES_PRAGMA_MARK
|
|
|
#pragma mark ***** Command Line Arguments
|
|
|
#endif
|
|
|
|
|
|
static const char kDefaultPIDFile[] = "/var/run/mDNSResponder.pid";
|
|
|
static const char kDefaultServiceType[] = "_afpovertcp._tcp.";
|
|
|
static const char kDefaultServiceDomain[] = "local.";
|
|
|
enum {
|
|
|
kDefaultPortNumber = 548
|
|
|
};
|
|
|
|
|
|
static void PrintUsage()
|
|
|
{
|
|
|
fprintf(stderr,
|
|
|
"Usage: %s [-v level ] [-r] [-n name] [-t type] [-d domain] [-p port] [-f file] [-b] [-P pidfile] [-x name=val ...]\n",
|
|
|
gProgramName);
|
|
|
fprintf(stderr, " -v verbose mode, level is a number from 0 to 2\n");
|
|
|
fprintf(stderr, " 0 = no debugging info (default)\n");
|
|
|
fprintf(stderr, " 1 = standard debugging info\n");
|
|
|
fprintf(stderr, " 2 = intense debugging info\n");
|
|
|
fprintf(stderr, " can be cycled kill -USR1\n");
|
|
|
fprintf(stderr, " -r also bind to port 53 (port 5353 is always bound)\n");
|
|
|
fprintf(stderr, " -n uses 'name' as the service name (required)\n");
|
|
|
fprintf(stderr, " -t uses 'type' as the service type (default is '%s')\n", kDefaultServiceType);
|
|
|
fprintf(stderr, " -d uses 'domain' as the service domain (default is '%s')\n", kDefaultServiceDomain);
|
|
|
fprintf(stderr, " -p uses 'port' as the port number (default is '%d')\n", kDefaultPortNumber);
|
|
|
fprintf(stderr, " -f reads a service list from 'file'\n");
|
|
|
fprintf(stderr, " -b forces daemon (background) mode\n");
|
|
|
fprintf(stderr, " -P uses 'pidfile' as the PID file\n");
|
|
|
fprintf(stderr, " (default is '%s')\n", kDefaultPIDFile);
|
|
|
fprintf(stderr, " only meaningful if -b also specified\n");
|
|
|
fprintf(stderr, " -x stores name=val in TXT record (default is empty).\n");
|
|
|
fprintf(stderr, " MUST be the last command-line argument;\n");
|
|
|
fprintf(stderr, " all subsequent arguments after -x are treated as name=val pairs.\n");
|
|
|
}
|
|
|
|
|
|
static mDNSBool gAvoidPort53 = mDNStrue;
|
|
|
static const char *gServiceName = "";
|
|
|
static const char *gServiceType = kDefaultServiceType;
|
|
|
static const char *gServiceDomain = kDefaultServiceDomain;
|
|
|
static mDNSu8 gServiceText[sizeof(RDataBody)];
|
|
|
static mDNSu16 gServiceTextLen = 0;
|
|
|
static int gPortNumber = kDefaultPortNumber;
|
|
|
static const char *gServiceFile = "";
|
|
|
static mDNSBool gDaemon = mDNSfalse;
|
|
|
static const char *gPIDFile = kDefaultPIDFile;
|
|
|
|
|
|
static void ParseArguments(int argc, char **argv)
|
|
|
// Parses our command line arguments into the global variables
|
|
|
// listed above.
|
|
|
{
|
|
|
int ch;
|
|
|
|
|
|
// Set gProgramName to the last path component of argv[0]
|
|
|
|
|
|
gProgramName = strrchr(argv[0], '/');
|
|
|
if (gProgramName == NULL) {
|
|
|
gProgramName = argv[0];
|
|
|
} else {
|
|
|
gProgramName += 1;
|
|
|
}
|
|
|
|
|
|
// Parse command line options using getopt.
|
|
|
|
|
|
do {
|
|
|
ch = getopt(argc, argv, "v:rn:t:d:p:f:dP:bx");
|
|
|
if (ch != -1) {
|
|
|
switch (ch) {
|
|
|
case 'v':
|
|
|
gMDNSPlatformPosixVerboseLevel = atoi(optarg);
|
|
|
if (gMDNSPlatformPosixVerboseLevel < 0 || gMDNSPlatformPosixVerboseLevel > 2) {
|
|
|
fprintf(stderr,
|
|
|
"%s: Verbose mode must be in the range 0..2\n",
|
|
|
gProgramName);
|
|
|
exit(1);
|
|
|
}
|
|
|
break;
|
|
|
case 'r':
|
|
|
gAvoidPort53 = mDNSfalse;
|
|
|
break;
|
|
|
case 'n':
|
|
|
gServiceName = optarg;
|
|
|
if ( ! CheckThatRichTextNameIsUsable(gServiceName, mDNStrue) ) {
|
|
|
exit(1);
|
|
|
}
|
|
|
break;
|
|
|
case 't':
|
|
|
gServiceType = optarg;
|
|
|
if ( ! CheckThatServiceTypeIsUsable(gServiceType, mDNStrue) ) {
|
|
|
exit(1);
|
|
|
}
|
|
|
break;
|
|
|
case 'd':
|
|
|
gServiceDomain = optarg;
|
|
|
break;
|
|
|
case 'p':
|
|
|
gPortNumber = atol(optarg);
|
|
|
if ( ! CheckThatPortNumberIsUsable(gPortNumber, mDNStrue) ) {
|
|
|
exit(1);
|
|
|
}
|
|
|
break;
|
|
|
case 'f':
|
|
|
gServiceFile = optarg;
|
|
|
break;
|
|
|
case 'b':
|
|
|
gDaemon = mDNStrue;
|
|
|
break;
|
|
|
case 'P':
|
|
|
gPIDFile = optarg;
|
|
|
break;
|
|
|
case 'x':
|
|
|
while (optind < argc)
|
|
|
{
|
|
|
gServiceText[gServiceTextLen] = strlen(argv[optind]);
|
|
|
mDNSPlatformMemCopy(gServiceText+gServiceTextLen+1, argv[optind], gServiceText[gServiceTextLen]);
|
|
|
gServiceTextLen += 1 + gServiceText[gServiceTextLen];
|
|
|
optind++;
|
|
|
}
|
|
|
ch = -1;
|
|
|
break;
|
|
|
case '?':
|
|
|
default:
|
|
|
PrintUsage();
|
|
|
exit(1);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
} while (ch != -1);
|
|
|
|
|
|
// Check for any left over command line arguments.
|
|
|
|
|
|
if (optind != argc) {
|
|
|
PrintUsage();
|
|
|
fprintf(stderr, "%s: Unexpected argument '%s'\n", gProgramName, argv[optind]);
|
|
|
exit(1);
|
|
|
}
|
|
|
|
|
|
// Check for inconsistency between the arguments.
|
|
|
|
|
|
if ( (gServiceName[0] == 0) && (gServiceFile[0] == 0) ) {
|
|
|
PrintUsage();
|
|
|
fprintf(stderr, "%s: You must specify a service name to register (-n) or a service file (-f).\n", gProgramName);
|
|
|
exit(1);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
#if COMPILER_LIKES_PRAGMA_MARK
|
|
|
#pragma mark ***** Registration
|
|
|
#endif
|
|
|
|
|
|
typedef struct PosixService PosixService;
|
|
|
|
|
|
struct PosixService {
|
|
|
ServiceRecordSet coreServ;
|
|
|
PosixService *next;
|
|
|
int serviceID;
|
|
|
};
|
|
|
|
|
|
static PosixService *gServiceList = NULL;
|
|
|
|
|
|
static void RegistrationCallback(mDNS *const m, ServiceRecordSet *const thisRegistration, mStatus status)
|
|
|
// mDNS core calls this routine to tell us about the status of
|
|
|
// our registration. The appropriate action to take depends
|
|
|
// entirely on the value of status.
|
|
|
{
|
|
|
switch (status) {
|
|
|
|
|
|
case mStatus_NoError:
|
|
|
debugf("Callback: %##s Name Registered", thisRegistration->RR_SRV.resrec.name->c);
|
|
|
// Do nothing; our name was successfully registered. We may
|
|
|
// get more call backs in the future.
|
|
|
break;
|
|
|
|
|
|
case mStatus_NameConflict:
|
|
|
debugf("Callback: %##s Name Conflict", thisRegistration->RR_SRV.resrec.name->c);
|
|
|
|
|
|
// In the event of a conflict, this sample RegistrationCallback
|
|
|
// just calls mDNS_RenameAndReregisterService to automatically
|
|
|
// pick a new unique name for the service. For a device such as a
|
|
|
// printer, this may be appropriate. For a device with a user
|
|
|
// interface, and a screen, and a keyboard, the appropriate response
|
|
|
// may be to prompt the user and ask them to choose a new name for
|
|
|
// the service.
|
|
|
//
|
|
|
// Also, what do we do if mDNS_RenameAndReregisterService returns an
|
|
|
// error. Right now I have no place to send that error to.
|
|
|
|
|
|
status = mDNS_RenameAndReregisterService(m, thisRegistration, mDNSNULL);
|
|
|
assert(status == mStatus_NoError);
|
|
|
break;
|
|
|
|
|
|
case mStatus_MemFree:
|
|
|
debugf("Callback: %##s Memory Free", thisRegistration->RR_SRV.resrec.name->c);
|
|
|
|
|
|
// When debugging is enabled, make sure that thisRegistration
|
|
|
// is not on our gServiceList.
|
|
|
|
|
|
#if !defined(NDEBUG)
|
|
|
{
|
|
|
PosixService *cursor;
|
|
|
|
|
|
cursor = gServiceList;
|
|
|
while (cursor != NULL) {
|
|
|
assert(&cursor->coreServ != thisRegistration);
|
|
|
cursor = cursor->next;
|
|
|
}
|
|
|
}
|
|
|
#endif
|
|
|
free(thisRegistration);
|
|
|
break;
|
|
|
|
|
|
default:
|
|
|
debugf("Callback: %##s Unknown Status %ld", thisRegistration->RR_SRV.resrec.name->c, status);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
static int gServiceID = 0;
|
|
|
|
|
|
static mStatus RegisterOneService(const char * richTextName,
|
|
|
const char * serviceType,
|
|
|
const char * serviceDomain,
|
|
|
const mDNSu8 text[],
|
|
|
mDNSu16 textLen,
|
|
|
long portNumber)
|
|
|
{
|
|
|
mStatus status;
|
|
|
PosixService * thisServ;
|
|
|
domainlabel name;
|
|
|
domainname type;
|
|
|
domainname domain;
|
|
|
|
|
|
status = mStatus_NoError;
|
|
|
thisServ = (PosixService *) malloc(sizeof(*thisServ));
|
|
|
if (thisServ == NULL) {
|
|
|
status = mStatus_NoMemoryErr;
|
|
|
}
|
|
|
if (status == mStatus_NoError) {
|
|
|
MakeDomainLabelFromLiteralString(&name, richTextName);
|
|
|
MakeDomainNameFromDNSNameString(&type, serviceType);
|
|
|
MakeDomainNameFromDNSNameString(&domain, serviceDomain);
|
|
|
status = mDNS_RegisterService(&mDNSStorage, &thisServ->coreServ,
|
|
|
&name, &type, &domain, // Name, type, domain
|
|
|
NULL, mDNSOpaque16fromIntVal(portNumber),
|
|
|
text, textLen, // TXT data, length
|
|
|
NULL, 0, // Subtypes
|
|
|
mDNSInterface_Any, // Interface ID
|
|
|
RegistrationCallback, thisServ, 0); // Callback, context, flags
|
|
|
}
|
|
|
if (status == mStatus_NoError) {
|
|
|
thisServ->serviceID = gServiceID;
|
|
|
gServiceID += 1;
|
|
|
|
|
|
thisServ->next = gServiceList;
|
|
|
gServiceList = thisServ;
|
|
|
|
|
|
if (gMDNSPlatformPosixVerboseLevel > 0) {
|
|
|
fprintf(stderr,
|
|
|
"%s: Registered service %d, name \"%s\", type \"%s\", domain \"%s\", port %ld\n",
|
|
|
gProgramName,
|
|
|
thisServ->serviceID,
|
|
|
richTextName,
|
|
|
serviceType,
|
|
|
serviceDomain,
|
|
|
portNumber);
|
|
|
}
|
|
|
} else {
|
|
|
if (thisServ != NULL) {
|
|
|
free(thisServ);
|
|
|
}
|
|
|
}
|
|
|
return status;
|
|
|
}
|
|
|
|
|
|
static mDNSBool ReadALine(char *buf, size_t bufSize, FILE *fp, mDNSBool skipBlankLines)
|
|
|
{
|
|
|
size_t len;
|
|
|
mDNSBool readNextLine;
|
|
|
|
|
|
do {
|
|
|
readNextLine = mDNSfalse;
|
|
|
|
|
|
if (fgets(buf, bufSize, fp) == NULL)
|
|
|
return mDNSfalse; // encountered EOF or an error condition
|
|
|
|
|
|
// These first characters indicate a blank line.
|
|
|
if (buf[0] == ' ' || buf[0] == '\t' || buf[0] == '\r' || buf[0] == '\n') {
|
|
|
if (!skipBlankLines)
|
|
|
return mDNSfalse;
|
|
|
readNextLine = mDNStrue;
|
|
|
}
|
|
|
// always skip comment lines
|
|
|
if (buf[0] == '#')
|
|
|
readNextLine = mDNStrue;
|
|
|
|
|
|
} while (readNextLine);
|
|
|
|
|
|
len = strlen( buf);
|
|
|
if ( buf[len - 1] == '\r' || buf[len - 1] == '\n')
|
|
|
buf[len - 1] = '\0';
|
|
|
|
|
|
return mDNStrue;
|
|
|
}
|
|
|
|
|
|
static mStatus RegisterServicesInFile(const char *filePath)
|
|
|
{
|
|
|
mStatus status = mStatus_NoError;
|
|
|
FILE * fp = fopen(filePath, "r");
|
|
|
|
|
|
if (fp == NULL) {
|
|
|
return mStatus_UnknownErr;
|
|
|
}
|
|
|
|
|
|
if (gMDNSPlatformPosixVerboseLevel > 1)
|
|
|
fprintf(stderr, "Parsing %s for services\n", filePath);
|
|
|
|
|
|
do {
|
|
|
char nameBuf[256];
|
|
|
char * name = nameBuf;
|
|
|
char type[256];
|
|
|
const char *dom = kDefaultServiceDomain;
|
|
|
char rawText[1024];
|
|
|
mDNSu8 text[sizeof(RDataBody)];
|
|
|
unsigned int textLen = 0;
|
|
|
char port[256];
|
|
|
char *p;
|
|
|
|
|
|
// Read the service name, type, port, and optional text record fields.
|
|
|
// Skip blank lines while looking for the next service name.
|
|
|
if (! ReadALine(name, sizeof(nameBuf), fp, mDNStrue))
|
|
|
break;
|
|
|
|
|
|
// Special case that allows service name to begin with a '#'
|
|
|
// character by escaping it with a '\' to distiguish it from
|
|
|
// a comment line. Remove the leading '\' here before
|
|
|
// registering the service.
|
|
|
if (name[0] == '\\' && name[1] == '#')
|
|
|
name++;
|
|
|
|
|
|
if (gMDNSPlatformPosixVerboseLevel > 1)
|
|
|
fprintf(stderr, "Service name: \"%s\"\n", name);
|
|
|
|
|
|
// Don't skip blank lines in calls to ReadAline() after finding the
|
|
|
// service name since the next blank line indicates the end
|
|
|
// of this service record.
|
|
|
if (! ReadALine(type, sizeof(type), fp, mDNSfalse))
|
|
|
break;
|
|
|
|
|
|
// see if a domain name is specified
|
|
|
p = type;
|
|
|
while (*p && *p != ' ' && *p != '\t') p++;
|
|
|
if (*p) {
|
|
|
*p = 0; // NULL terminate the <type>.<protocol> string
|
|
|
// skip any leading whitespace before domain name
|
|
|
p++;
|
|
|
while (*p && (*p == ' ' || *p == '\t')) p++;
|
|
|
if (*p)
|
|
|
dom = p;
|
|
|
}
|
|
|
if (gMDNSPlatformPosixVerboseLevel > 1) {
|
|
|
fprintf(stderr, "Service type: \"%s\"\n", type);
|
|
|
fprintf(stderr, "Service domain: \"%s\"\n", dom);
|
|
|
}
|
|
|
|
|
|
if (! ReadALine(port, sizeof(port), fp, mDNSfalse))
|
|
|
break;
|
|
|
if (gMDNSPlatformPosixVerboseLevel > 1)
|
|
|
fprintf(stderr, "Service port: %s\n", port);
|
|
|
|
|
|
if ( ! CheckThatRichTextNameIsUsable(name, mDNStrue)
|
|
|
|| ! CheckThatServiceTypeIsUsable(type, mDNStrue)
|
|
|
|| ! CheckThatPortNumberIsUsable(atol(port), mDNStrue))
|
|
|
break;
|
|
|
|
|
|
// read the TXT record fields
|
|
|
while (1) {
|
|
|
int len;
|
|
|
if (!ReadALine(rawText, sizeof(rawText), fp, mDNSfalse)) break;
|
|
|
if (gMDNSPlatformPosixVerboseLevel > 1)
|
|
|
fprintf(stderr, "Text string: \"%s\"\n", rawText);
|
|
|
len = strlen(rawText);
|
|
|
if (len <= 255)
|
|
|
{
|
|
|
unsigned int newlen = textLen + 1 + len;
|
|
|
if (len == 0 || newlen >= sizeof(text)) break;
|
|
|
text[textLen] = len;
|
|
|
mDNSPlatformMemCopy(text + textLen + 1, rawText, len);
|
|
|
textLen = newlen;
|
|
|
}
|
|
|
else
|
|
|
fprintf(stderr, "%s: TXT attribute too long for name = %s, type = %s, port = %s\n",
|
|
|
gProgramName, name, type, port);
|
|
|
}
|
|
|
|
|
|
status = RegisterOneService(name, type, dom, text, textLen, atol(port));
|
|
|
if (status != mStatus_NoError) {
|
|
|
// print error, but try to read and register other services in the file
|
|
|
fprintf(stderr, "%s: Failed to register service, name \"%s\", type \"%s\", domain \"%s\", port %s\n",
|
|
|
gProgramName, name, type, dom, port);
|
|
|
}
|
|
|
|
|
|
} while (!feof(fp));
|
|
|
|
|
|
if (!feof(fp)) {
|
|
|
fprintf(stderr, "%s: Error reading service file %s\n", gProgramName, filePath);
|
|
|
status = mStatus_UnknownErr;
|
|
|
}
|
|
|
|
|
|
{
|
|
|
// __ANDROID__ : replaced assert(fclose(..))
|
|
|
int fp_closed = fclose(fp);
|
|
|
assert(0 == fp_closed);
|
|
|
}
|
|
|
|
|
|
return status;
|
|
|
}
|
|
|
|
|
|
static mStatus RegisterOurServices(void)
|
|
|
{
|
|
|
mStatus status;
|
|
|
|
|
|
status = mStatus_NoError;
|
|
|
if (gServiceName[0] != 0) {
|
|
|
status = RegisterOneService(gServiceName,
|
|
|
gServiceType,
|
|
|
gServiceDomain,
|
|
|
gServiceText, gServiceTextLen,
|
|
|
gPortNumber);
|
|
|
}
|
|
|
if (status == mStatus_NoError && gServiceFile[0] != 0) {
|
|
|
status = RegisterServicesInFile(gServiceFile);
|
|
|
}
|
|
|
return status;
|
|
|
}
|
|
|
|
|
|
static void DeregisterOurServices(void)
|
|
|
{
|
|
|
PosixService *thisServ;
|
|
|
int thisServID;
|
|
|
|
|
|
while (gServiceList != NULL) {
|
|
|
thisServ = gServiceList;
|
|
|
gServiceList = thisServ->next;
|
|
|
|
|
|
thisServID = thisServ->serviceID;
|
|
|
|
|
|
mDNS_DeregisterService(&mDNSStorage, &thisServ->coreServ);
|
|
|
|
|
|
if (gMDNSPlatformPosixVerboseLevel > 0) {
|
|
|
fprintf(stderr,
|
|
|
"%s: Deregistered service %d\n",
|
|
|
gProgramName,
|
|
|
thisServ->serviceID);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
#if COMPILER_LIKES_PRAGMA_MARK
|
|
|
#pragma mark **** Main
|
|
|
#endif
|
|
|
|
|
|
int main(int argc, char **argv)
|
|
|
{
|
|
|
mStatus status;
|
|
|
int result;
|
|
|
|
|
|
// Parse our command line arguments. This won't come back if there's an error.
|
|
|
|
|
|
ParseArguments(argc, argv);
|
|
|
|
|
|
// If we're told to run as a daemon, then do that straight away.
|
|
|
// Note that we don't treat the inability to create our PID
|
|
|
// file as an error. Also note that we assign getpid to a long
|
|
|
// because printf has no format specified for pid_t.
|
|
|
|
|
|
if (gDaemon) {
|
|
|
int result;
|
|
|
if (gMDNSPlatformPosixVerboseLevel > 0) {
|
|
|
fprintf(stderr, "%s: Starting in daemon mode\n", gProgramName);
|
|
|
}
|
|
|
result = daemon(0,0);
|
|
|
if (result == 0) {
|
|
|
FILE *fp;
|
|
|
int junk;
|
|
|
|
|
|
fp = fopen(gPIDFile, "w");
|
|
|
if (fp != NULL) {
|
|
|
fprintf(fp, "%ld\n", (long) getpid());
|
|
|
junk = fclose(fp);
|
|
|
assert(junk == 0);
|
|
|
}
|
|
|
} else {
|
|
|
fprintf(stderr, "%s: Could not run as daemon - exiting\n", gProgramName);
|
|
|
exit(result);
|
|
|
}
|
|
|
} else {
|
|
|
if (gMDNSPlatformPosixVerboseLevel > 0) {
|
|
|
fprintf(stderr, "%s: Starting in foreground mode, PID %ld\n", gProgramName, (long) getpid());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
status = mDNS_Init(&mDNSStorage, &PlatformStorage,
|
|
|
mDNS_Init_NoCache, mDNS_Init_ZeroCacheSize,
|
|
|
mDNS_Init_AdvertiseLocalAddresses,
|
|
|
mDNS_Init_NoInitCallback, mDNS_Init_NoInitCallbackContext);
|
|
|
if (status != mStatus_NoError) return(2);
|
|
|
|
|
|
status = RegisterOurServices();
|
|
|
if (status != mStatus_NoError) return(2);
|
|
|
|
|
|
signal(SIGHUP, HandleSigHup); // SIGHUP has to be sent by kill -HUP <pid>
|
|
|
signal(SIGINT, HandleSigInt); // SIGINT is what you get for a Ctrl-C
|
|
|
signal(SIGQUIT, HandleSigQuit); // SIGQUIT is what you get for a Ctrl-\ (indeed)
|
|
|
signal(SIGUSR1, HandleSigUsr1); // SIGUSR1 has to be sent by kill -USR1 <pid>
|
|
|
|
|
|
while (!gStopNow)
|
|
|
{
|
|
|
int nfds = 0;
|
|
|
fd_set readfds;
|
|
|
struct timeval timeout;
|
|
|
int result;
|
|
|
|
|
|
// 1. Set up the fd_set as usual here.
|
|
|
// This example client has no file descriptors of its own,
|
|
|
// but a real application would call FD_SET to add them to the set here
|
|
|
FD_ZERO(&readfds);
|
|
|
|
|
|
// 2. Set up the timeout.
|
|
|
// This example client has no other work it needs to be doing,
|
|
|
// so we set an effectively infinite timeout
|
|
|
timeout.tv_sec = 0x3FFFFFFF;
|
|
|
timeout.tv_usec = 0;
|
|
|
|
|
|
// 3. Give the mDNSPosix layer a chance to add its information to the fd_set and timeout
|
|
|
mDNSPosixGetFDSet(&mDNSStorage, &nfds, &readfds, &timeout);
|
|
|
|
|
|
// 4. Call select as normal
|
|
|
verbosedebugf("select(%d, %d.%06d)", nfds, timeout.tv_sec, timeout.tv_usec);
|
|
|
result = select(nfds, &readfds, NULL, NULL, &timeout);
|
|
|
|
|
|
if (result < 0)
|
|
|
{
|
|
|
verbosedebugf("select() returned %d errno %d", result, errno);
|
|
|
if (errno != EINTR) gStopNow = mDNStrue;
|
|
|
else
|
|
|
{
|
|
|
if (gReceivedSigUsr1)
|
|
|
{
|
|
|
gReceivedSigUsr1 = mDNSfalse;
|
|
|
gMDNSPlatformPosixVerboseLevel += 1;
|
|
|
if (gMDNSPlatformPosixVerboseLevel > 2)
|
|
|
gMDNSPlatformPosixVerboseLevel = 0;
|
|
|
if ( gMDNSPlatformPosixVerboseLevel > 0 )
|
|
|
fprintf(stderr, "\nVerbose level %d\n", gMDNSPlatformPosixVerboseLevel);
|
|
|
}
|
|
|
if (gReceivedSigHup)
|
|
|
{
|
|
|
if (gMDNSPlatformPosixVerboseLevel > 0)
|
|
|
fprintf(stderr, "\nSIGHUP\n");
|
|
|
gReceivedSigHup = mDNSfalse;
|
|
|
DeregisterOurServices();
|
|
|
status = mDNSPlatformPosixRefreshInterfaceList(&mDNSStorage);
|
|
|
if (status != mStatus_NoError) break;
|
|
|
status = RegisterOurServices();
|
|
|
if (status != mStatus_NoError) break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
// 5. Call mDNSPosixProcessFDSet to let the mDNSPosix layer do its work
|
|
|
mDNSPosixProcessFDSet(&mDNSStorage, &readfds);
|
|
|
|
|
|
// 6. This example client has no other work it needs to be doing,
|
|
|
// but a real client would do its work here
|
|
|
// ... (do work) ...
|
|
|
}
|
|
|
}
|
|
|
|
|
|
debugf("Exiting");
|
|
|
|
|
|
DeregisterOurServices();
|
|
|
mDNS_Close(&mDNSStorage);
|
|
|
|
|
|
if (status == mStatus_NoError) {
|
|
|
result = 0;
|
|
|
} else {
|
|
|
result = 2;
|
|
|
}
|
|
|
if ( (result != 0) || (gMDNSPlatformPosixVerboseLevel > 0) ) {
|
|
|
fprintf(stderr, "%s: Finished with status %d, result %d\n", gProgramName, (int)status, result);
|
|
|
}
|
|
|
|
|
|
return result;
|
|
|
}
|
