/***************************************************************************/
/* */
/* Project: OpenSLP command line UA wrapper */
/* */
/* File: slptool.c */
/* */
/* Abstract: Command line wrapper for OpenSLP */
/* */
/* Requires: OpenSLP installation */
/* */
/* Author(s): Matt Peterson <mpeterson@caldera.com> */
/* */
/* Copyright (c) 1995, 1999 Caldera Systems, Inc. */
/* */
/* This program is free software; you can redistribute it and/or modify it */
/* under the terms of the GNU Lesser General Public License as published */
/* by the Free Software Foundation; either version 2.1 of the License, or */
/* (at your option) any later version. */
/* */
/* This program 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 Lesser General Public License for more details. */
/* */
/* You should have received a copy of the GNU Lesser General Public */
/* License along with this program; see the file COPYING. If not, */
/* please obtain a copy from http://www.gnu.org/copyleft/lesser.html */
/* */
/*-------------------------------------------------------------------------*/
/* */
/* Please submit patches to maintainer of http://www.openslp.org */
/* */
/***************************************************************************/
#include "slptool.h"
#ifdef _WIN32
# define strncasecmp(String1, String2, Num) strnicmp(String1, String2, Num)
# define strcasecmp(String1, String2) stricmp(String1, String2)
# define inet_aton(opt,bind) ((bind)->s_addr = inet_addr(opt))
#else
# ifdef HAVE_CONFIG_H
# include "config.h"
# define SLP_VERSION VERSION
# else
# define SLP_VERSION 1.2.1
# endif
# ifndef HAVE_STRNCASECMP
int strncasecmp(const char *s1, const char *s2, size_t len);
# endif
# ifndef HAVE_STRCASECMP
int strcasecmp(const char *s1, const char *s2);
# endif
#endif
/*=========================================================================*/
SLPBoolean mySrvTypeCallback( SLPHandle hslp,
const char* srvtypes,
SLPError errcode,
void* cookie )
/*=========================================================================*/
{
char* cpy;
char* slider1;
char* slider2;
if(errcode == SLP_OK && *srvtypes)
{
cpy = strdup(srvtypes);
if(cpy)
{
slider1 = slider2 = cpy;
slider1 = strchr(slider2,',');
while(slider1)
{
*slider1 = 0;
printf("%s\n",slider2);
slider1 ++;
slider2 = slider1;
slider1 = strchr(slider2,',');
}
/* print the final itam */
printf("%s\n",slider2);
free(cpy);
}
}
return SLP_TRUE;
}
/*=========================================================================*/
void FindSrvTypes(SLPToolCommandLine* cmdline)
/*=========================================================================*/
{
SLPError result;
SLPHandle hslp;
if(SLPOpen(cmdline->lang,SLP_FALSE,&hslp) == SLP_OK)
{
if(cmdline->cmdparam1)
{
result = SLPFindSrvTypes(hslp,
cmdline->cmdparam1,
cmdline->scopes,
mySrvTypeCallback,
0);
}
else
{
result = SLPFindSrvTypes(hslp,
"*",
cmdline->scopes,
mySrvTypeCallback,
0);
}
if(result != SLP_OK)
{
printf("errorcode: %i\n",result);
}
SLPClose(hslp);
}
}
#ifndef UNICAST_NOT_SUPPORTED
/*=========================================================================*/
void UnicastFindSrvTypes(SLPToolCommandLine* cmdline)
/*=========================================================================*/
{
SLPError result;
SLPHandle hslp;
if(SLPOpen(cmdline->lang,SLP_FALSE,&hslp) == SLP_OK) {
if((result = SLPAssociateIP(hslp, cmdline->cmdparam3)) != SLP_OK)
{
printf("errorcode: %i\n",result);
SLPClose(hslp);
return;
}
if(cmdline->cmdparam1)
{
result = SLPFindSrvTypes(hslp,
cmdline->cmdparam1,
cmdline->scopes,
mySrvTypeCallback,
0);
}
else
{
result = SLPFindSrvTypes(hslp,
"*",
cmdline->scopes,
mySrvTypeCallback,
0);
}
if(result != SLP_OK)
{
printf("errorcode: %i\n",result);
}
SLPClose(hslp);
}
}
#endif
#ifndef MI_NOT_SUPPORTED
/*=========================================================================*/
void FindSrvTypesUsingIFList(SLPToolCommandLine* cmdline)
/*=========================================================================*/
{
SLPError result;
SLPHandle hslp;
if(SLPOpen(cmdline->lang,SLP_FALSE,&hslp) == SLP_OK)
{
if((result = SLPAssociateIFList(hslp, cmdline->cmdparam3)) != SLP_OK)
{
printf("errorcode: %i\n",result);
SLPClose(hslp);
return;
}
if(cmdline->cmdparam1)
{
result = SLPFindSrvTypes(hslp,
cmdline->cmdparam1,
cmdline->scopes,
mySrvTypeCallback,
0);
}
else
{
result = SLPFindSrvTypes(hslp,
"*",
cmdline->scopes,
mySrvTypeCallback,
0);
}
if(result != SLP_OK)
{
printf("errorcode: %i\n",result);
}
SLPClose(hslp);
}
}
#endif /* MI_NOT_SUPPORTED */
/*=========================================================================*/
SLPBoolean myAttrCallback(SLPHandle hslp,
const char* attrlist,
SLPError errcode,
void* cookie )
/*=========================================================================*/
{
if(errcode == SLP_OK)
{
printf("%s\n",attrlist);
}
return SLP_TRUE;
}
/*=========================================================================*/
void FindAttrs(SLPToolCommandLine* cmdline)
/*=========================================================================*/
{
SLPError result;
SLPHandle hslp;
if(SLPOpen(cmdline->lang,SLP_FALSE,&hslp) == SLP_OK)
{
result = SLPFindAttrs(hslp,
cmdline->cmdparam1,
cmdline->scopes,
cmdline->cmdparam2,
myAttrCallback,
0);
if(result != SLP_OK)
{
printf("errorcode: %i\n",result);
}
SLPClose(hslp);
}
}
#ifndef UNICAST_NOT_SUPPORTED
/*=========================================================================*/
void UnicastFindAttrs(SLPToolCommandLine* cmdline)
/*=========================================================================*/
{
SLPError result;
SLPHandle hslp;
if(SLPOpen(cmdline->lang,SLP_FALSE,&hslp) == SLP_OK) {
if((result = SLPAssociateIP(hslp, cmdline->cmdparam3)) != SLP_OK)
{
printf("errorcode: %i\n",result);
SLPClose(hslp);
return;
}
result = SLPFindAttrs(hslp,
cmdline->cmdparam1,
cmdline->scopes,
cmdline->cmdparam2,
myAttrCallback,
0);
if(result != SLP_OK)
{
printf("errorcode: %i\n",result);
}
SLPClose(hslp);
}
}
#endif
#ifndef MI_NOT_SUPPORTED
/*=========================================================================*/
void FindAttrsUsingIFList(SLPToolCommandLine* cmdline)
/*=========================================================================*/
{
SLPError result;
SLPHandle hslp;
if(SLPOpen(cmdline->lang,SLP_FALSE,&hslp) == SLP_OK)
{
if((result = SLPAssociateIFList(hslp, cmdline->cmdparam3)) != SLP_OK)
{
printf("errorcode: %i\n",result);
SLPClose(hslp);
return;
}
result = SLPFindAttrs(hslp,
cmdline->cmdparam1,
cmdline->scopes,
cmdline->cmdparam2,
myAttrCallback,
0);
if(result != SLP_OK)
{
printf("errorcode: %i\n",result);
}
SLPClose(hslp);
}
}
#endif /* MI_NOT_SUPPORTED */
/*=========================================================================*/
SLPBoolean mySrvUrlCallback( SLPHandle hslp,
const char* srvurl,
unsigned short lifetime,
SLPError errcode,
void* cookie )
/*=========================================================================*/
{
if(errcode == SLP_OK)
{
printf("%s,%i\n",srvurl,lifetime);
}
return SLP_TRUE;
}
/*=========================================================================*/
void FindSrvs(SLPToolCommandLine* cmdline)
/*=========================================================================*/
{
SLPError result;
SLPHandle hslp;
if(SLPOpen(cmdline->lang,SLP_FALSE,&hslp) == SLP_OK)
{
result = SLPFindSrvs(hslp,
cmdline->cmdparam1,
cmdline->scopes,
cmdline->cmdparam2,
mySrvUrlCallback,
0);
if(result != SLP_OK)
{
printf("errorcode: %i\n",result);
}
SLPClose(hslp);
}
}
#ifndef MI_NOT_SUPPORTED
/*=========================================================================*/
void FindSrvsUsingIFList(SLPToolCommandLine* cmdline)
/*=========================================================================*/
{
SLPError result;
SLPHandle hslp;
if(SLPOpen(cmdline->lang,SLP_FALSE,&hslp) == SLP_OK)
{
if((result = SLPAssociateIFList(hslp, cmdline->cmdparam3)) != SLP_OK)
{
printf("errorcode: %i\n",result);
SLPClose(hslp);
return;
}
result = SLPFindSrvs(hslp,
cmdline->cmdparam1,
cmdline->scopes,
cmdline->cmdparam2,
mySrvUrlCallback,
0);
if(result != SLP_OK)
{
printf("errorcode: %i\n",result);
}
SLPClose(hslp);
}
}
#endif /* MI_NOT_SUPPORTED */
#ifndef UNICAST_NOT_SUPPORTED
/*=========================================================================*/
void UnicastFindSrvs(SLPToolCommandLine* cmdline)
/*=========================================================================*/
{
SLPError result;
SLPHandle hslp;
if(SLPOpen(cmdline->lang,SLP_FALSE,&hslp) == SLP_OK) {
if((result = SLPAssociateIP(hslp, cmdline->cmdparam3)) != SLP_OK)
{
printf("errorcode: %i\n",result);
SLPClose(hslp);
return;
}
result = SLPFindSrvs(hslp,
cmdline->cmdparam1,
cmdline->scopes,
cmdline->cmdparam2,
mySrvUrlCallback,
0);
if(result != SLP_OK)
{
printf("errorcode: %i\n",result);
}
SLPClose(hslp);
}
}
#endif
/*=========================================================================*/
void FindScopes(SLPToolCommandLine* cmdline)
/*=========================================================================*/
{
SLPError result;
SLPHandle hslp;
char* scopes;
if(SLPOpen(cmdline->lang,SLP_FALSE,&hslp) == SLP_OK)
{
result = SLPFindScopes(hslp,&scopes);
if(result == SLP_OK)
{
printf("%s\n",scopes);
SLPFree(scopes);
}
SLPClose(hslp);
}
}
/*-------------------------------------------------------------------------*/
void mySLPRegReport(SLPHandle hslp, SLPError errcode, void* cookie)
{
if (errcode)
printf("(de)registration errorcode %d\n", errcode);
}
/*=========================================================================*/
void Register(SLPToolCommandLine* cmdline)
/*=========================================================================*/
{
SLPError result;
SLPHandle hslp;
char srvtype[80] = "", *s;
int len = 0;
if (strncasecmp(cmdline->cmdparam1, "service:", 8) == 0)
len = 8;
s = strchr(cmdline->cmdparam1 + len, ':');
if (!s)
{
printf("Invalid URL: %s\n", cmdline->cmdparam1);
return;
}
len = s - cmdline->cmdparam1;
strncpy(srvtype, cmdline->cmdparam1, len);
srvtype[len] = 0;
if(SLPOpen(cmdline->lang,SLP_FALSE,&hslp) == SLP_OK)
{
result = SLPReg(hslp,
cmdline->cmdparam1,
SLP_LIFETIME_MAXIMUM,
srvtype,
cmdline->cmdparam2,
SLP_TRUE,
mySLPRegReport,
0);
if(result != SLP_OK)
{
printf("errorcode: %i\n",result);
}
SLPClose(hslp);
}
}
/*=========================================================================*/
void Deregister(SLPToolCommandLine* cmdline)
/*=========================================================================*/
{
SLPError result;
SLPHandle hslp;
if(SLPOpen(cmdline->lang,SLP_FALSE,&hslp) == SLP_OK)
{
result = SLPDereg(hslp,
cmdline->cmdparam1,
mySLPRegReport,
0);
if(result != SLP_OK)
{
printf("errorcode: %i\n",result);
}
SLPClose(hslp);
}
}
/*=========================================================================*/
void PrintVersion(SLPToolCommandLine* cmdline)
/*=========================================================================*/
{
printf("slptool version = %s\n", SLP_VERSION);
printf("libslp version = %s\n",
SLPGetProperty("net.slp.OpenSLPVersion"));
printf("libslp configuration file = %s\n",
SLPGetProperty("net.slp.OpenSLPConfigFile"));
}
/*=========================================================================*/
void GetProperty(SLPToolCommandLine* cmdline)
/*=========================================================================*/
{
const char* propertyValue;
propertyValue = SLPGetProperty(cmdline->cmdparam1);
printf("%s = %s\n",
cmdline->cmdparam1,
propertyValue == 0 ? "" : propertyValue);
}
/*=========================================================================*/
int ParseCommandLine(int argc,char* argv[], SLPToolCommandLine* cmdline)
/* Returns Zero on success. Non-zero on error. */
/*=========================================================================*/
{
int i;
if(argc < 2)
{
/* not enough arguments */
return 1;
}
for (i=1;i<argc;i++)
{
if( strcasecmp(argv[i],"-v") == 0 ||
strcasecmp(argv[i],"--version") == 0 )
{
if(i < argc)
{
cmdline->cmd = PRINT_VERSION;
return 0;
}
else
{
return 1;
}
}
else if( strcasecmp(argv[i],"-s") == 0 ||
strcasecmp(argv[i],"--scopes") == 0 )
{
i++;
if(i < argc)
{
cmdline->scopes = argv[i];
}
else
{
return 1;
}
}
else if( strcasecmp(argv[i],"-l") == 0 ||
strcasecmp(argv[i],"--lang") == 0 )
{
i++;
if(i < argc)
{
cmdline->lang = argv[i];
}
else
{
return 1;
}
}
else if(strcasecmp(argv[i],"findsrvs") == 0)
{
cmdline->cmd = FINDSRVS;
/* service type */
i++;
if(i < argc)
{
cmdline->cmdparam1 = argv[i];
}
else
{
return 1;
}
/* (optional) filter */
i++;
if(i < argc)
{
cmdline->cmdparam2 = argv[i];
}
break;
}
#ifndef MI_NOT_SUPPORTED
else if(strcasecmp(argv[i],"findsrvsusingiflist") == 0)
{
cmdline->cmd = FINDSRVSUSINGIFLIST;
/* (required) IFList */
i++;
if(i < argc)
{
cmdline->cmdparam3 = argv[i];
}
else
{
return 1;
}
/* service type */
i++;
if(i < argc)
{
cmdline->cmdparam1 = argv[i];
}
else
{
return 1;
}
/* (optional) filter */
i++;
if(i < argc)
{
cmdline->cmdparam2 = argv[i];
}
break;
}
#endif /* MI_NOT_SUPPORTED */
#ifndef UNICAST_NOT_SUPPORTED
else if(strcasecmp(argv[i],"unicastfindsrvs") == 0)
{
cmdline->cmd = UNICASTFINDSRVS;
i++;
if(i < argc)
{
cmdline->cmdparam3 = argv[i];
}
else
{
return 1;
}
/* service type */
i++;
if(i < argc)
{
cmdline->cmdparam1 = argv[i];
} else {
return 1;
}
/* optional filter */
i++;
if(i < argc)
{
cmdline->cmdparam2 = argv[i];
}
break;
}
#endif
else if(strcasecmp(argv[i],"findattrs") == 0)
{
cmdline->cmd = FINDATTRS;
/* url or service type */
i++;
if(i < argc)
{
cmdline->cmdparam1 = argv[i];
}
else
{
return 1;
}
/* (optional) attrids */
i++;
if(i < argc)
{
cmdline->cmdparam2 = argv[i];
}
}
#ifndef UNICAST_NOT_SUPPORTED
else if(strcasecmp(argv[i],"unicastfindattrs") == 0)
{
cmdline->cmd = UNICASTFINDATTRS;
/* unicast IP address */
i++;
if(i < argc)
{
cmdline->cmdparam3 = argv[i];
}
else
{
return 1;
}
/* url or service type */
i++;
if(i < argc)
{
cmdline->cmdparam1 = argv[i];
} else {
return 1;
}
/* optional filter */
i++;
if(i < argc)
{
cmdline->cmdparam2 = argv[i];
}
break;
}
#endif
#ifndef MI_NOT_SUPPORTED
else if(strcasecmp(argv[i],"findattrsusingiflist") == 0)
{
cmdline->cmd = FINDATTRSUSINGIFLIST;
/* (required) IFList */
i++;
if(i < argc)
{
cmdline->cmdparam3 = argv[i];
}
else
{
return 1;
}
/* url or service type */
i++;
if(i < argc)
{
cmdline->cmdparam1 = argv[i];
}
else
{
return 1;
}
/* (optional) attrids */
i++;
if(i < argc)
{
cmdline->cmdparam2 = argv[i];
}
}
#endif /* MI_NOT_SUPPORTED */
else if(strcasecmp(argv[i],"findsrvtypes") == 0)
{
cmdline->cmd = FINDSRVTYPES;
/* (optional) naming authority */
i++;
if(i < argc)
{
cmdline->cmdparam1 = argv[i];
}
}
#ifndef UNICAST_NOT_SUPPORTED
else if(strcasecmp(argv[i],"unicastfindsrvtypes") == 0)
{
cmdline->cmd = UNICASTFINDSRVTYPES;
/* unicast IP address */
i++;
if(i < argc)
{
cmdline->cmdparam3 = argv[i];
}
else
{
return 1;
}
/* (optional) naming authority */
i++;
if(i < argc)
{
cmdline->cmdparam1 = argv[i];
}
}
#endif
#ifndef MI_NOT_SUPPORTED
else if(strcasecmp(argv[i],"findsrvtypesusingiflist") == 0)
{
cmdline->cmd = FINDSRVTYPESUSINGIFLIST;
/* (required) IFList */
i++;
if(i < argc)
{
cmdline->cmdparam3 = argv[i];
}
else
{
return 1;
}
/* (optional) naming authority */
i++;
if(i < argc)
{
cmdline->cmdparam1 = argv[i];
}
}
#endif /* MI_NOT_SUPPORTED */
else if(strcasecmp(argv[i],"findscopes") == 0)
{
cmdline->cmd = FINDSCOPES;
}
else if(strcasecmp(argv[i],"register") == 0)
{
cmdline->cmd = REGISTER;
/* url */
i++;
if(i < argc)
{
cmdline->cmdparam1 = argv[i];
}
else
{
return 1;
}
/* Optional attrids */
i++;
if(i < argc)
{
cmdline->cmdparam2 = argv[i];
}
else
{
cmdline->cmdparam2 = cmdline->cmdparam1 + strlen(cmdline->cmdparam1);
}
break;
}
else if(strcasecmp(argv[i],"deregister") == 0)
{
cmdline->cmd = DEREGISTER;
/* url */
i++;
if(i < argc)
{
cmdline->cmdparam1 = argv[i];
}
else
{
return 1;
}
}
else if(strcasecmp(argv[i],"getproperty") == 0)
{
cmdline->cmd = GETPROPERTY;
i++;
if(i < argc)
{
cmdline->cmdparam1 = argv[i];
}
else
{
return 1;
}
}
else
{
return 1;
}
}
return 0;
}
/*=========================================================================*/
void DisplayUsage()
/*=========================================================================*/
{
printf("Usage: slptool [options] command-and-arguments \n");
printf(" options may be:\n");
printf(" -v (or --version) displays version of slptool and OpenSLP\n");
printf(" -s (or --scope) followed by a comma separated list of scopes\n");
printf(" -l (or --language) followed by a language tag\n");
printf(" command-and-arguments may be:\n");
printf(" findsrvs service-type [filter]\n");
#ifndef MI_NOT_SUPPORTED
printf(" findsrvsusingiflist interface-list service-type [filter]\n");
#endif /* MI_NOT_SUPPORTED */
#ifndef UNICAST_NOT_SUPPORTED
printf(" unicastfindsrvs ip-address service-type [filter]\n");
#endif
printf(" findattrs url [attrids]\n");
#ifndef UNICAST_NOT_SUPPORTED
printf(" unicastfindattrs ip-address url [attrids]\n");
#endif
#ifndef MI_NOT_SUPPORTED
printf(" findattrsusingiflist interface-list url [attrids]\n");
#endif /* MI_NOT_SUPPORTED */
printf(" findsrvtypes [authority]\n");
#ifndef UNICAST_NOT_SUPPORTED
printf(" unicastfindsrvtypes [authority]\n");
#endif
#ifndef MI_NOT_SUPPORTED
printf(" findsrvtypesusingiflist interface-list [authority]\n");
#endif /* MI_NOT_SUPPORTED */
printf(" findscopes\n");
printf(" register url [attrs]\n");
printf(" deregister url\n");
printf(" getproperty propertyname\n");
printf("Examples:\n");
printf(" slptool register service:myserv.x://myhost.com \"(attr1=val1),(attr2=val2)\"\n");
printf(" slptool findsrvs service:myserv.x\n");
printf(" slptool findsrvs service:myserv.x \"(attr1=val1)\"\n");
#ifndef MI_NOT_SUPPORTED
printf(" slptool findsrvsusingiflist 10.77.13.240,192.168.250.240 service:myserv.x\n");
printf(" slptool findsrvsusingiflist 10.77.13.243 service:myserv.x \"(attr1=val1)\"\n");
#endif /* MI_NOT_SUPPORTED */
#ifndef UNICAST_NOT_SUPPORTED
printf(" slptool unicastfindsrvs 10.77.13.237 service:myserv.x\n");
printf(" slptool unicastfindsrvs 10.77.13.237 service:myserv.x \"(attr1=val1)\"\n");
#endif
printf(" slptool findattrs service:myserv.x://myhost.com\n");
printf(" slptool findattrs service:myserv.x://myhost.com attr1\n");
#ifndef UNICAST_NOT_SUPPORTED
printf(" slptool unicastfindattrs 10.77.13.237 service:myserv.x\n");
printf(" slptool unicastfindattrs 10.77.13.237 service:myserv.x://myhost.com attr1 \n");
#endif
#ifndef MI_NOT_SUPPORTED
printf(" slptool findattrsusingiflist 10.77.13.240,192.168.250.240 service:myserv.x://myhost.com\n");
printf(" slptool findattrsusingiflist 10.77.13.243 service:myserv.x://myhost.com attr1\n");
#endif /* MI_NOT_SUPPORTED */
printf(" slptool deregister service:myserv.x://myhost.com\n");
printf(" slptool getproperty net.slp.useScopes\n");
}
/*=========================================================================*/
int main(int argc, char* argv[])
/*=========================================================================*/
{
int result;
SLPToolCommandLine cmdline;
/* zero out the cmdline */
memset(&cmdline,0,sizeof(cmdline));
/* Parse the command line */
if(ParseCommandLine(argc,argv,&cmdline) == 0)
{
switch(cmdline.cmd)
{
case FINDSRVS:
FindSrvs(&cmdline);
break;
#ifndef UNICAST_NOT_SUPPORTED
case UNICASTFINDSRVS:
UnicastFindSrvs(&cmdline);
break;
#endif
case FINDATTRS:
FindAttrs(&cmdline);
break;
#ifndef UNICAST_NOT_SUPPORTED
case UNICASTFINDATTRS:
UnicastFindAttrs(&cmdline);
break;
#endif
case FINDSRVTYPES:
FindSrvTypes(&cmdline);
break;
#ifndef UNICAST_NOT_SUPPORTED
case UNICASTFINDSRVTYPES:
UnicastFindSrvTypes(&cmdline);
break;
#endif
case FINDSCOPES:
FindScopes(&cmdline);
break;
case GETPROPERTY:
GetProperty(&cmdline);
break;
case REGISTER:
Register(&cmdline);
break;
case DEREGISTER:
Deregister(&cmdline);
break;
#ifndef MI_NOT_SUPPORTED
case FINDSRVSUSINGIFLIST:
FindSrvsUsingIFList(&cmdline);
break;
case FINDATTRSUSINGIFLIST:
FindAttrsUsingIFList(&cmdline);
break;
case FINDSRVTYPESUSINGIFLIST:
FindSrvTypesUsingIFList(&cmdline);
break;
#endif /* MI_NOT_SUPPORTED */
case PRINT_VERSION:
PrintVersion(&cmdline);
break;
case DUMMY:
break;
}
}
else
{
DisplayUsage();
result = 1;
}
return 0;
}
syntax highlighted by Code2HTML, v. 0.9.1