Return to srvreg.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / rsync

rsync 3.2.3

    1: /* -*- c-file-style: "linux"; -*-
    2: 
    3:    Copyright (C) 2002 by Brad Hards <bradh@frogmouth.net>
    4: 
    5:    This program is free software; you can redistribute it and/or modify
    6:    it under the terms of the GNU General Public License as published by
    7:    the Free Software Foundation; either version 2 of the License, or
    8:    (at your option) any later version.
    9: 
   10:    This program is distributed in the hope that it will be useful,
   11:    but WITHOUT ANY WARRANTY; without even the implied warranty of
   12:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   13:    GNU General Public License for more details.
   14: 
   15:    You should have received a copy of the GNU General Public License
   16:    along with this program; if not, write to the Free Software
   17:    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   18: */
   19: 
   20: /* This file implements the service registration functionality */
   21: 
   22: /* Basically, it uses normal Service Location Protocol API */
   23: 
   24: #include "rsync.h"
   25: #include "slp.h"
   26: #include "netdb.h"
   27: 
   28: extern int rsync_port;
   29: 
   30: static void slp_callback(UNUSED(SLPHandle hslp), SLPError errcode, void *cookie)
   31: {
   32: 	/* return the error code in the cookie */
   33: 	*(SLPError*)cookie = errcode;
   34: 
   35: 	/* You could do something else here like print out
   36: 	 * the errcode, etc.  Remember, as a general rule,
   37: 	 * do not try to do too much in a callback because
   38: 	 * it is being executed by the same thread that is
   39: 	 * reading slp packets from the wire. */
   40: }
   41: 
   42: int register_services(void)
   43: {
   44: 	SLPError err, callbackerr;
   45: 	SLPHandle hslp;
   46: 	int n;
   47: 	int i;
   48: 	char srv[120];
   49: 	char attr[120];
   50: 	char localhost[256];
   51: 	extern char *config_file;
   52: 	short timeout;
   53: 	struct addrinfo aih, *ai = 0;
   54: 
   55: 	if (!lp_load(config_file, 0)) {
   56: 		exit_cleanup(RERR_SYNTAX);
   57: 	}
   58: 
   59: 	n = lp_num_modules();
   60: 
   61: 	if (0 == lp_slp_refresh())
   62: 		timeout = SLP_LIFETIME_MAXIMUM; /* don't expire, ever */
   63: 	else if (SLP_MIN_TIMEOUT > lp_slp_refresh())
   64: 		timeout = SLP_MIN_TIMEOUT; /* use a reasonable minimum */
   65: 	else if (SLP_LIFETIME_MAXIMUM <= lp_slp_refresh())
   66: 		timeout = (SLP_LIFETIME_MAXIMUM - 1); /* as long as possible */
   67: 	else
   68: 		timeout = lp_slp_refresh();
   69: 
   70: 	rprintf(FINFO, "rsyncd registering %d service%s with slpd for %d seconds:\n", n, ((n==1)? "":"s"), timeout);
   71: 	err = SLPOpen("en",SLP_FALSE,&hslp);
   72: 	if (err != SLP_OK) {
   73: 		rprintf(FINFO, "Error opening slp handle %i\n",err);
   74: 		return err;
   75: 	}
   76: 	if (gethostname(localhost, sizeof localhost)) {
   77: 	       rprintf(FINFO, "Could not get hostname: %s\n", strerror(errno));
   78: 	       return err;
   79: 	}
   80: 	memset(&aih, 0, sizeof aih);
   81: 	aih.ai_family = PF_UNSPEC;
   82: 	aih.ai_flags = AI_CANONNAME;
   83: 	if (0 != (err = getaddrinfo(localhost, 0, &aih, &ai)) || !ai) {
   84: 	       rprintf(FINFO, "Could not resolve hostname: %s\n", gai_strerror(err));
   85: 	       return err;
   86: 	}
   87: 	/* Register each service with SLP */
   88: 	for (i = 0; i < n; i++) {
   89: 		if (!lp_list(i))
   90: 			continue;
   91: 
   92: 		snprintf(srv, sizeof srv, "service:rsync://%s:%d/%s",
   93: 			 ai->ai_canonname,
   94: 			 rsync_port,
   95: 			 lp_name(i));
   96: 		rprintf(FINFO, "    %s\n", srv);
   97: 		if (lp_comment(i)) {
   98: 			snprintf(attr, sizeof attr, "(comment=%s)",
   99: 				 lp_comment(i));
  100: 		}
  101: 		err = SLPReg(hslp,
  102: 			     srv, /* service to register */
  103: 			     timeout,
  104: 			     0,  /* this is ignored */
  105: 			     attr, /* attributes */
  106: 			     SLP_TRUE, /* new registration - don't change this */
  107: 			     slp_callback, /* callback */
  108: 			     &callbackerr);
  109: 
  110: 		/* err may contain an error code that occurred as the slp library
  111: 		 * _prepared_ to make the call. */
  112: 		if (err != SLP_OK || callbackerr != SLP_OK)
  113: 			rprintf(FINFO, "Error registering service with slp %i\n", err);
  114: 
  115: 		/* callbackerr may contain an error code (that was assigned through
  116: 		 * the callback cookie) that occurred as slp packets were sent on
  117: 		 * the wire. */
  118: 		if (callbackerr != SLP_OK)
  119: 			rprintf(FINFO, "Error registering service with slp %i\n",callbackerr);
  120: 	}
  121: 
  122: 	/* Now that we're done using slp, close the slp handle */
  123: 	freeaddrinfo(ai);
  124: 	SLPClose(hslp);
  125: 
  126: 	/* refresh is done in main select loop */
  127: 	return 0;
  128: }