Return to srvreg.c CVS log

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

Annotation of embedaddon/rsync/srvreg.c, revision 1.1.1.1

1.1       misho       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: }