/branches/stable-1-2-0/openslp/slptool/slptool.c

# · C · 1068 lines · 842 code · 124 blank · 102 comment · 162 complexity · 14c99851108907cf85e2dce42acbe72d MD5 · raw file

  1. /***************************************************************************/
  2. /* */
  3. /* Project: OpenSLP command line UA wrapper */
  4. /* */
  5. /* File: slptool.c */
  6. /* */
  7. /* Abstract: Command line wrapper for OpenSLP */
  8. /* */
  9. /* Requires: OpenSLP installation */
  10. /* */
  11. /* Author(s): Matt Peterson <mpeterson@caldera.com> */
  12. /* */
  13. /* Copyright (c) 1995, 1999 Caldera Systems, Inc. */
  14. /* */
  15. /* This program is free software; you can redistribute it and/or modify it */
  16. /* under the terms of the GNU Lesser General Public License as published */
  17. /* by the Free Software Foundation; either version 2.1 of the License, or */
  18. /* (at your option) any later version. */
  19. /* */
  20. /* This program is distributed in the hope that it will be useful, */
  21. /* but WITHOUT ANY WARRANTY; without even the implied warranty of */
  22. /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
  23. /* GNU Lesser General Public License for more details. */
  24. /* */
  25. /* You should have received a copy of the GNU Lesser General Public */
  26. /* License along with this program; see the file COPYING. If not, */
  27. /* please obtain a copy from http://www.gnu.org/copyleft/lesser.html */
  28. /* */
  29. /*-------------------------------------------------------------------------*/
  30. /* */
  31. /* Please submit patches to maintainer of http://www.openslp.org */
  32. /* */
  33. /***************************************************************************/
  34. #include "slptool.h"
  35. #ifdef _WIN32
  36. # define strncasecmp(String1, String2, Num) strnicmp(String1, String2, Num)
  37. # define strcasecmp(String1, String2) stricmp(String1, String2)
  38. # define inet_aton(opt,bind) ((bind)->s_addr = inet_addr(opt))
  39. #else
  40. # ifdef HAVE_CONFIG_H
  41. # include "config.h"
  42. # define SLP_VERSION VERSION
  43. # else
  44. # define SLP_VERSION 1.2.1
  45. # endif
  46. # ifndef HAVE_STRNCASECMP
  47. int strncasecmp(const char *s1, const char *s2, size_t len);
  48. # endif
  49. # ifndef HAVE_STRCASECMP
  50. int strcasecmp(const char *s1, const char *s2);
  51. # endif
  52. #endif
  53. /*=========================================================================*/
  54. SLPBoolean mySrvTypeCallback( SLPHandle hslp,
  55. const char* srvtypes,
  56. SLPError errcode,
  57. void* cookie )
  58. /*=========================================================================*/
  59. {
  60. char* cpy;
  61. char* slider1;
  62. char* slider2;
  63. if(errcode == SLP_OK && *srvtypes)
  64. {
  65. cpy = strdup(srvtypes);
  66. if(cpy)
  67. {
  68. slider1 = slider2 = cpy;
  69. slider1 = strchr(slider2,',');
  70. while(slider1)
  71. {
  72. *slider1 = 0;
  73. printf("%s\n",slider2);
  74. slider1 ++;
  75. slider2 = slider1;
  76. slider1 = strchr(slider2,',');
  77. }
  78. /* print the final itam */
  79. printf("%s\n",slider2);
  80. free(cpy);
  81. }
  82. }
  83. return SLP_TRUE;
  84. }
  85. /*=========================================================================*/
  86. void FindSrvTypes(SLPToolCommandLine* cmdline)
  87. /*=========================================================================*/
  88. {
  89. SLPError result;
  90. SLPHandle hslp;
  91. if(SLPOpen(cmdline->lang,SLP_FALSE,&hslp) == SLP_OK)
  92. {
  93. if(cmdline->cmdparam1)
  94. {
  95. result = SLPFindSrvTypes(hslp,
  96. cmdline->cmdparam1,
  97. cmdline->scopes,
  98. mySrvTypeCallback,
  99. 0);
  100. }
  101. else
  102. {
  103. result = SLPFindSrvTypes(hslp,
  104. "*",
  105. cmdline->scopes,
  106. mySrvTypeCallback,
  107. 0);
  108. }
  109. if(result != SLP_OK)
  110. {
  111. printf("errorcode: %i\n",result);
  112. }
  113. SLPClose(hslp);
  114. }
  115. }
  116. #ifndef UNICAST_NOT_SUPPORTED
  117. /*=========================================================================*/
  118. void UnicastFindSrvTypes(SLPToolCommandLine* cmdline)
  119. /*=========================================================================*/
  120. {
  121. SLPError result;
  122. SLPHandle hslp;
  123. if(SLPOpen(cmdline->lang,SLP_FALSE,&hslp) == SLP_OK) {
  124. if((result = SLPAssociateIP(hslp, cmdline->cmdparam3)) != SLP_OK)
  125. {
  126. printf("errorcode: %i\n",result);
  127. SLPClose(hslp);
  128. return;
  129. }
  130. if(cmdline->cmdparam1)
  131. {
  132. result = SLPFindSrvTypes(hslp,
  133. cmdline->cmdparam1,
  134. cmdline->scopes,
  135. mySrvTypeCallback,
  136. 0);
  137. }
  138. else
  139. {
  140. result = SLPFindSrvTypes(hslp,
  141. "*",
  142. cmdline->scopes,
  143. mySrvTypeCallback,
  144. 0);
  145. }
  146. if(result != SLP_OK)
  147. {
  148. printf("errorcode: %i\n",result);
  149. }
  150. SLPClose(hslp);
  151. }
  152. }
  153. #endif
  154. #ifndef MI_NOT_SUPPORTED
  155. /*=========================================================================*/
  156. void FindSrvTypesUsingIFList(SLPToolCommandLine* cmdline)
  157. /*=========================================================================*/
  158. {
  159. SLPError result;
  160. SLPHandle hslp;
  161. if(SLPOpen(cmdline->lang,SLP_FALSE,&hslp) == SLP_OK)
  162. {
  163. if((result = SLPAssociateIFList(hslp, cmdline->cmdparam3)) != SLP_OK)
  164. {
  165. printf("errorcode: %i\n",result);
  166. SLPClose(hslp);
  167. return;
  168. }
  169. if(cmdline->cmdparam1)
  170. {
  171. result = SLPFindSrvTypes(hslp,
  172. cmdline->cmdparam1,
  173. cmdline->scopes,
  174. mySrvTypeCallback,
  175. 0);
  176. }
  177. else
  178. {
  179. result = SLPFindSrvTypes(hslp,
  180. "*",
  181. cmdline->scopes,
  182. mySrvTypeCallback,
  183. 0);
  184. }
  185. if(result != SLP_OK)
  186. {
  187. printf("errorcode: %i\n",result);
  188. }
  189. SLPClose(hslp);
  190. }
  191. }
  192. #endif /* MI_NOT_SUPPORTED */
  193. /*=========================================================================*/
  194. SLPBoolean myAttrCallback(SLPHandle hslp,
  195. const char* attrlist,
  196. SLPError errcode,
  197. void* cookie )
  198. /*=========================================================================*/
  199. {
  200. if(errcode == SLP_OK)
  201. {
  202. printf("%s\n",attrlist);
  203. }
  204. return SLP_TRUE;
  205. }
  206. /*=========================================================================*/
  207. void FindAttrs(SLPToolCommandLine* cmdline)
  208. /*=========================================================================*/
  209. {
  210. SLPError result;
  211. SLPHandle hslp;
  212. if(SLPOpen(cmdline->lang,SLP_FALSE,&hslp) == SLP_OK)
  213. {
  214. result = SLPFindAttrs(hslp,
  215. cmdline->cmdparam1,
  216. cmdline->scopes,
  217. cmdline->cmdparam2,
  218. myAttrCallback,
  219. 0);
  220. if(result != SLP_OK)
  221. {
  222. printf("errorcode: %i\n",result);
  223. }
  224. SLPClose(hslp);
  225. }
  226. }
  227. #ifndef UNICAST_NOT_SUPPORTED
  228. /*=========================================================================*/
  229. void UnicastFindAttrs(SLPToolCommandLine* cmdline)
  230. /*=========================================================================*/
  231. {
  232. SLPError result;
  233. SLPHandle hslp;
  234. if(SLPOpen(cmdline->lang,SLP_FALSE,&hslp) == SLP_OK) {
  235. if((result = SLPAssociateIP(hslp, cmdline->cmdparam3)) != SLP_OK)
  236. {
  237. printf("errorcode: %i\n",result);
  238. SLPClose(hslp);
  239. return;
  240. }
  241. result = SLPFindAttrs(hslp,
  242. cmdline->cmdparam1,
  243. cmdline->scopes,
  244. cmdline->cmdparam2,
  245. myAttrCallback,
  246. 0);
  247. if(result != SLP_OK)
  248. {
  249. printf("errorcode: %i\n",result);
  250. }
  251. SLPClose(hslp);
  252. }
  253. }
  254. #endif
  255. #ifndef MI_NOT_SUPPORTED
  256. /*=========================================================================*/
  257. void FindAttrsUsingIFList(SLPToolCommandLine* cmdline)
  258. /*=========================================================================*/
  259. {
  260. SLPError result;
  261. SLPHandle hslp;
  262. if(SLPOpen(cmdline->lang,SLP_FALSE,&hslp) == SLP_OK)
  263. {
  264. if((result = SLPAssociateIFList(hslp, cmdline->cmdparam3)) != SLP_OK)
  265. {
  266. printf("errorcode: %i\n",result);
  267. SLPClose(hslp);
  268. return;
  269. }
  270. result = SLPFindAttrs(hslp,
  271. cmdline->cmdparam1,
  272. cmdline->scopes,
  273. cmdline->cmdparam2,
  274. myAttrCallback,
  275. 0);
  276. if(result != SLP_OK)
  277. {
  278. printf("errorcode: %i\n",result);
  279. }
  280. SLPClose(hslp);
  281. }
  282. }
  283. #endif /* MI_NOT_SUPPORTED */
  284. /*=========================================================================*/
  285. SLPBoolean mySrvUrlCallback( SLPHandle hslp,
  286. const char* srvurl,
  287. unsigned short lifetime,
  288. SLPError errcode,
  289. void* cookie )
  290. /*=========================================================================*/
  291. {
  292. if(errcode == SLP_OK)
  293. {
  294. printf("%s,%i\n",srvurl,lifetime);
  295. }
  296. return SLP_TRUE;
  297. }
  298. /*=========================================================================*/
  299. void FindSrvs(SLPToolCommandLine* cmdline)
  300. /*=========================================================================*/
  301. {
  302. SLPError result;
  303. SLPHandle hslp;
  304. if(SLPOpen(cmdline->lang,SLP_FALSE,&hslp) == SLP_OK)
  305. {
  306. result = SLPFindSrvs(hslp,
  307. cmdline->cmdparam1,
  308. cmdline->scopes,
  309. cmdline->cmdparam2,
  310. mySrvUrlCallback,
  311. 0);
  312. if(result != SLP_OK)
  313. {
  314. printf("errorcode: %i\n",result);
  315. }
  316. SLPClose(hslp);
  317. }
  318. }
  319. #ifndef MI_NOT_SUPPORTED
  320. /*=========================================================================*/
  321. void FindSrvsUsingIFList(SLPToolCommandLine* cmdline)
  322. /*=========================================================================*/
  323. {
  324. SLPError result;
  325. SLPHandle hslp;
  326. if(SLPOpen(cmdline->lang,SLP_FALSE,&hslp) == SLP_OK)
  327. {
  328. if((result = SLPAssociateIFList(hslp, cmdline->cmdparam3)) != SLP_OK)
  329. {
  330. printf("errorcode: %i\n",result);
  331. SLPClose(hslp);
  332. return;
  333. }
  334. result = SLPFindSrvs(hslp,
  335. cmdline->cmdparam1,
  336. cmdline->scopes,
  337. cmdline->cmdparam2,
  338. mySrvUrlCallback,
  339. 0);
  340. if(result != SLP_OK)
  341. {
  342. printf("errorcode: %i\n",result);
  343. }
  344. SLPClose(hslp);
  345. }
  346. }
  347. #endif /* MI_NOT_SUPPORTED */
  348. #ifndef UNICAST_NOT_SUPPORTED
  349. /*=========================================================================*/
  350. void UnicastFindSrvs(SLPToolCommandLine* cmdline)
  351. /*=========================================================================*/
  352. {
  353. SLPError result;
  354. SLPHandle hslp;
  355. if(SLPOpen(cmdline->lang,SLP_FALSE,&hslp) == SLP_OK) {
  356. if((result = SLPAssociateIP(hslp, cmdline->cmdparam3)) != SLP_OK)
  357. {
  358. printf("errorcode: %i\n",result);
  359. SLPClose(hslp);
  360. return;
  361. }
  362. result = SLPFindSrvs(hslp,
  363. cmdline->cmdparam1,
  364. cmdline->scopes,
  365. cmdline->cmdparam2,
  366. mySrvUrlCallback,
  367. 0);
  368. if(result != SLP_OK)
  369. {
  370. printf("errorcode: %i\n",result);
  371. }
  372. SLPClose(hslp);
  373. }
  374. }
  375. #endif
  376. /*=========================================================================*/
  377. void FindScopes(SLPToolCommandLine* cmdline)
  378. /*=========================================================================*/
  379. {
  380. SLPError result;
  381. SLPHandle hslp;
  382. char* scopes;
  383. if(SLPOpen(cmdline->lang,SLP_FALSE,&hslp) == SLP_OK)
  384. {
  385. result = SLPFindScopes(hslp,&scopes);
  386. if(result == SLP_OK)
  387. {
  388. printf("%s\n",scopes);
  389. SLPFree(scopes);
  390. }
  391. SLPClose(hslp);
  392. }
  393. }
  394. /*-------------------------------------------------------------------------*/
  395. void mySLPRegReport(SLPHandle hslp, SLPError errcode, void* cookie)
  396. {
  397. if (errcode)
  398. printf("(de)registration errorcode %d\n", errcode);
  399. }
  400. /*=========================================================================*/
  401. void Register(SLPToolCommandLine* cmdline)
  402. /*=========================================================================*/
  403. {
  404. SLPError result;
  405. SLPHandle hslp;
  406. char srvtype[80] = "", *s;
  407. int len = 0;
  408. if (strncasecmp(cmdline->cmdparam1, "service:", 8) == 0)
  409. len = 8;
  410. s = strchr(cmdline->cmdparam1 + len, ':');
  411. if (!s)
  412. {
  413. printf("Invalid URL: %s\n", cmdline->cmdparam1);
  414. return;
  415. }
  416. len = s - cmdline->cmdparam1;
  417. strncpy(srvtype, cmdline->cmdparam1, len);
  418. srvtype[len] = 0;
  419. if(SLPOpen(cmdline->lang,SLP_FALSE,&hslp) == SLP_OK)
  420. {
  421. result = SLPReg(hslp,
  422. cmdline->cmdparam1,
  423. SLP_LIFETIME_MAXIMUM,
  424. srvtype,
  425. cmdline->cmdparam2,
  426. SLP_TRUE,
  427. mySLPRegReport,
  428. 0);
  429. if(result != SLP_OK)
  430. {
  431. printf("errorcode: %i\n",result);
  432. }
  433. SLPClose(hslp);
  434. }
  435. }
  436. /*=========================================================================*/
  437. void Deregister(SLPToolCommandLine* cmdline)
  438. /*=========================================================================*/
  439. {
  440. SLPError result;
  441. SLPHandle hslp;
  442. if(SLPOpen(cmdline->lang,SLP_FALSE,&hslp) == SLP_OK)
  443. {
  444. result = SLPDereg(hslp,
  445. cmdline->cmdparam1,
  446. mySLPRegReport,
  447. 0);
  448. if(result != SLP_OK)
  449. {
  450. printf("errorcode: %i\n",result);
  451. }
  452. SLPClose(hslp);
  453. }
  454. }
  455. /*=========================================================================*/
  456. void PrintVersion(SLPToolCommandLine* cmdline)
  457. /*=========================================================================*/
  458. {
  459. printf("slptool version = %s\n", SLP_VERSION);
  460. printf("libslp version = %s\n",
  461. SLPGetProperty("net.slp.OpenSLPVersion"));
  462. printf("libslp configuration file = %s\n",
  463. SLPGetProperty("net.slp.OpenSLPConfigFile"));
  464. }
  465. /*=========================================================================*/
  466. void GetProperty(SLPToolCommandLine* cmdline)
  467. /*=========================================================================*/
  468. {
  469. const char* propertyValue;
  470. propertyValue = SLPGetProperty(cmdline->cmdparam1);
  471. printf("%s = %s\n",
  472. cmdline->cmdparam1,
  473. propertyValue == 0 ? "" : propertyValue);
  474. }
  475. /*=========================================================================*/
  476. int ParseCommandLine(int argc,char* argv[], SLPToolCommandLine* cmdline)
  477. /* Returns Zero on success. Non-zero on error. */
  478. /*=========================================================================*/
  479. {
  480. int i;
  481. if(argc < 2)
  482. {
  483. /* not enough arguments */
  484. return 1;
  485. }
  486. for (i=1;i<argc;i++)
  487. {
  488. if( strcasecmp(argv[i],"-v") == 0 ||
  489. strcasecmp(argv[i],"--version") == 0 )
  490. {
  491. if(i < argc)
  492. {
  493. cmdline->cmd = PRINT_VERSION;
  494. return 0;
  495. }
  496. else
  497. {
  498. return 1;
  499. }
  500. }
  501. else if( strcasecmp(argv[i],"-s") == 0 ||
  502. strcasecmp(argv[i],"--scopes") == 0 )
  503. {
  504. i++;
  505. if(i < argc)
  506. {
  507. cmdline->scopes = argv[i];
  508. }
  509. else
  510. {
  511. return 1;
  512. }
  513. }
  514. else if( strcasecmp(argv[i],"-l") == 0 ||
  515. strcasecmp(argv[i],"--lang") == 0 )
  516. {
  517. i++;
  518. if(i < argc)
  519. {
  520. cmdline->lang = argv[i];
  521. }
  522. else
  523. {
  524. return 1;
  525. }
  526. }
  527. else if(strcasecmp(argv[i],"findsrvs") == 0)
  528. {
  529. cmdline->cmd = FINDSRVS;
  530. /* service type */
  531. i++;
  532. if(i < argc)
  533. {
  534. cmdline->cmdparam1 = argv[i];
  535. }
  536. else
  537. {
  538. return 1;
  539. }
  540. /* (optional) filter */
  541. i++;
  542. if(i < argc)
  543. {
  544. cmdline->cmdparam2 = argv[i];
  545. }
  546. break;
  547. }
  548. #ifndef MI_NOT_SUPPORTED
  549. else if(strcasecmp(argv[i],"findsrvsusingiflist") == 0)
  550. {
  551. cmdline->cmd = FINDSRVSUSINGIFLIST;
  552. /* (required) IFList */
  553. i++;
  554. if(i < argc)
  555. {
  556. cmdline->cmdparam3 = argv[i];
  557. }
  558. else
  559. {
  560. return 1;
  561. }
  562. /* service type */
  563. i++;
  564. if(i < argc)
  565. {
  566. cmdline->cmdparam1 = argv[i];
  567. }
  568. else
  569. {
  570. return 1;
  571. }
  572. /* (optional) filter */
  573. i++;
  574. if(i < argc)
  575. {
  576. cmdline->cmdparam2 = argv[i];
  577. }
  578. break;
  579. }
  580. #endif /* MI_NOT_SUPPORTED */
  581. #ifndef UNICAST_NOT_SUPPORTED
  582. else if(strcasecmp(argv[i],"unicastfindsrvs") == 0)
  583. {
  584. cmdline->cmd = UNICASTFINDSRVS;
  585. i++;
  586. if(i < argc)
  587. {
  588. cmdline->cmdparam3 = argv[i];
  589. }
  590. else
  591. {
  592. return 1;
  593. }
  594. /* service type */
  595. i++;
  596. if(i < argc)
  597. {
  598. cmdline->cmdparam1 = argv[i];
  599. } else {
  600. return 1;
  601. }
  602. /* optional filter */
  603. i++;
  604. if(i < argc)
  605. {
  606. cmdline->cmdparam2 = argv[i];
  607. }
  608. break;
  609. }
  610. #endif
  611. else if(strcasecmp(argv[i],"findattrs") == 0)
  612. {
  613. cmdline->cmd = FINDATTRS;
  614. /* url or service type */
  615. i++;
  616. if(i < argc)
  617. {
  618. cmdline->cmdparam1 = argv[i];
  619. }
  620. else
  621. {
  622. return 1;
  623. }
  624. /* (optional) attrids */
  625. i++;
  626. if(i < argc)
  627. {
  628. cmdline->cmdparam2 = argv[i];
  629. }
  630. }
  631. #ifndef UNICAST_NOT_SUPPORTED
  632. else if(strcasecmp(argv[i],"unicastfindattrs") == 0)
  633. {
  634. cmdline->cmd = UNICASTFINDATTRS;
  635. /* unicast IP address */
  636. i++;
  637. if(i < argc)
  638. {
  639. cmdline->cmdparam3 = argv[i];
  640. }
  641. else
  642. {
  643. return 1;
  644. }
  645. /* url or service type */
  646. i++;
  647. if(i < argc)
  648. {
  649. cmdline->cmdparam1 = argv[i];
  650. } else {
  651. return 1;
  652. }
  653. /* optional filter */
  654. i++;
  655. if(i < argc)
  656. {
  657. cmdline->cmdparam2 = argv[i];
  658. }
  659. break;
  660. }
  661. #endif
  662. #ifndef MI_NOT_SUPPORTED
  663. else if(strcasecmp(argv[i],"findattrsusingiflist") == 0)
  664. {
  665. cmdline->cmd = FINDATTRSUSINGIFLIST;
  666. /* (required) IFList */
  667. i++;
  668. if(i < argc)
  669. {
  670. cmdline->cmdparam3 = argv[i];
  671. }
  672. else
  673. {
  674. return 1;
  675. }
  676. /* url or service type */
  677. i++;
  678. if(i < argc)
  679. {
  680. cmdline->cmdparam1 = argv[i];
  681. }
  682. else
  683. {
  684. return 1;
  685. }
  686. /* (optional) attrids */
  687. i++;
  688. if(i < argc)
  689. {
  690. cmdline->cmdparam2 = argv[i];
  691. }
  692. }
  693. #endif /* MI_NOT_SUPPORTED */
  694. else if(strcasecmp(argv[i],"findsrvtypes") == 0)
  695. {
  696. cmdline->cmd = FINDSRVTYPES;
  697. /* (optional) naming authority */
  698. i++;
  699. if(i < argc)
  700. {
  701. cmdline->cmdparam1 = argv[i];
  702. }
  703. }
  704. #ifndef UNICAST_NOT_SUPPORTED
  705. else if(strcasecmp(argv[i],"unicastfindsrvtypes") == 0)
  706. {
  707. cmdline->cmd = UNICASTFINDSRVTYPES;
  708. /* unicast IP address */
  709. i++;
  710. if(i < argc)
  711. {
  712. cmdline->cmdparam3 = argv[i];
  713. }
  714. else
  715. {
  716. return 1;
  717. }
  718. /* (optional) naming authority */
  719. i++;
  720. if(i < argc)
  721. {
  722. cmdline->cmdparam1 = argv[i];
  723. }
  724. }
  725. #endif
  726. #ifndef MI_NOT_SUPPORTED
  727. else if(strcasecmp(argv[i],"findsrvtypesusingiflist") == 0)
  728. {
  729. cmdline->cmd = FINDSRVTYPESUSINGIFLIST;
  730. /* (required) IFList */
  731. i++;
  732. if(i < argc)
  733. {
  734. cmdline->cmdparam3 = argv[i];
  735. }
  736. else
  737. {
  738. return 1;
  739. }
  740. /* (optional) naming authority */
  741. i++;
  742. if(i < argc)
  743. {
  744. cmdline->cmdparam1 = argv[i];
  745. }
  746. }
  747. #endif /* MI_NOT_SUPPORTED */
  748. else if(strcasecmp(argv[i],"findscopes") == 0)
  749. {
  750. cmdline->cmd = FINDSCOPES;
  751. }
  752. else if(strcasecmp(argv[i],"register") == 0)
  753. {
  754. cmdline->cmd = REGISTER;
  755. /* url */
  756. i++;
  757. if(i < argc)
  758. {
  759. cmdline->cmdparam1 = argv[i];
  760. }
  761. else
  762. {
  763. return 1;
  764. }
  765. /* Optional attrids */
  766. i++;
  767. if(i < argc)
  768. {
  769. cmdline->cmdparam2 = argv[i];
  770. }
  771. else
  772. {
  773. cmdline->cmdparam2 = cmdline->cmdparam1 + strlen(cmdline->cmdparam1);
  774. }
  775. break;
  776. }
  777. else if(strcasecmp(argv[i],"deregister") == 0)
  778. {
  779. cmdline->cmd = DEREGISTER;
  780. /* url */
  781. i++;
  782. if(i < argc)
  783. {
  784. cmdline->cmdparam1 = argv[i];
  785. }
  786. else
  787. {
  788. return 1;
  789. }
  790. }
  791. else if(strcasecmp(argv[i],"getproperty") == 0)
  792. {
  793. cmdline->cmd = GETPROPERTY;
  794. i++;
  795. if(i < argc)
  796. {
  797. cmdline->cmdparam1 = argv[i];
  798. }
  799. else
  800. {
  801. return 1;
  802. }
  803. }
  804. else
  805. {
  806. return 1;
  807. }
  808. }
  809. return 0;
  810. }
  811. /*=========================================================================*/
  812. void DisplayUsage()
  813. /*=========================================================================*/
  814. {
  815. printf("Usage: slptool [options] command-and-arguments \n");
  816. printf(" options may be:\n");
  817. printf(" -v (or --version) displays version of slptool and OpenSLP\n");
  818. printf(" -s (or --scope) followed by a comma separated list of scopes\n");
  819. printf(" -l (or --language) followed by a language tag\n");
  820. printf(" command-and-arguments may be:\n");
  821. printf(" findsrvs service-type [filter]\n");
  822. #ifndef MI_NOT_SUPPORTED
  823. printf(" findsrvsusingiflist interface-list service-type [filter]\n");
  824. #endif /* MI_NOT_SUPPORTED */
  825. #ifndef UNICAST_NOT_SUPPORTED
  826. printf(" unicastfindsrvs ip-address service-type [filter]\n");
  827. #endif
  828. printf(" findattrs url [attrids]\n");
  829. #ifndef UNICAST_NOT_SUPPORTED
  830. printf(" unicastfindattrs ip-address url [attrids]\n");
  831. #endif
  832. #ifndef MI_NOT_SUPPORTED
  833. printf(" findattrsusingiflist interface-list url [attrids]\n");
  834. #endif /* MI_NOT_SUPPORTED */
  835. printf(" findsrvtypes [authority]\n");
  836. #ifndef UNICAST_NOT_SUPPORTED
  837. printf(" unicastfindsrvtypes [authority]\n");
  838. #endif
  839. #ifndef MI_NOT_SUPPORTED
  840. printf(" findsrvtypesusingiflist interface-list [authority]\n");
  841. #endif /* MI_NOT_SUPPORTED */
  842. printf(" findscopes\n");
  843. printf(" register url [attrs]\n");
  844. printf(" deregister url\n");
  845. printf(" getproperty propertyname\n");
  846. printf("Examples:\n");
  847. printf(" slptool register service:myserv.x://myhost.com \"(attr1=val1),(attr2=val2)\"\n");
  848. printf(" slptool findsrvs service:myserv.x\n");
  849. printf(" slptool findsrvs service:myserv.x \"(attr1=val1)\"\n");
  850. #ifndef MI_NOT_SUPPORTED
  851. printf(" slptool findsrvsusingiflist 10.77.13.240,192.168.250.240 service:myserv.x\n");
  852. printf(" slptool findsrvsusingiflist 10.77.13.243 service:myserv.x \"(attr1=val1)\"\n");
  853. #endif /* MI_NOT_SUPPORTED */
  854. #ifndef UNICAST_NOT_SUPPORTED
  855. printf(" slptool unicastfindsrvs 10.77.13.237 service:myserv.x\n");
  856. printf(" slptool unicastfindsrvs 10.77.13.237 service:myserv.x \"(attr1=val1)\"\n");
  857. #endif
  858. printf(" slptool findattrs service:myserv.x://myhost.com\n");
  859. printf(" slptool findattrs service:myserv.x://myhost.com attr1\n");
  860. #ifndef UNICAST_NOT_SUPPORTED
  861. printf(" slptool unicastfindattrs 10.77.13.237 service:myserv.x\n");
  862. printf(" slptool unicastfindattrs 10.77.13.237 service:myserv.x://myhost.com attr1 \n");
  863. #endif
  864. #ifndef MI_NOT_SUPPORTED
  865. printf(" slptool findattrsusingiflist 10.77.13.240,192.168.250.240 service:myserv.x://myhost.com\n");
  866. printf(" slptool findattrsusingiflist 10.77.13.243 service:myserv.x://myhost.com attr1\n");
  867. #endif /* MI_NOT_SUPPORTED */
  868. printf(" slptool deregister service:myserv.x://myhost.com\n");
  869. printf(" slptool getproperty net.slp.useScopes\n");
  870. }
  871. /*=========================================================================*/
  872. int main(int argc, char* argv[])
  873. /*=========================================================================*/
  874. {
  875. int result;
  876. SLPToolCommandLine cmdline;
  877. /* zero out the cmdline */
  878. memset(&cmdline,0,sizeof(cmdline));
  879. /* Parse the command line */
  880. if(ParseCommandLine(argc,argv,&cmdline) == 0)
  881. {
  882. switch(cmdline.cmd)
  883. {
  884. case FINDSRVS:
  885. FindSrvs(&cmdline);
  886. break;
  887. #ifndef UNICAST_NOT_SUPPORTED
  888. case UNICASTFINDSRVS:
  889. UnicastFindSrvs(&cmdline);
  890. break;
  891. #endif
  892. case FINDATTRS:
  893. FindAttrs(&cmdline);
  894. break;
  895. #ifndef UNICAST_NOT_SUPPORTED
  896. case UNICASTFINDATTRS:
  897. UnicastFindAttrs(&cmdline);
  898. break;
  899. #endif
  900. case FINDSRVTYPES:
  901. FindSrvTypes(&cmdline);
  902. break;
  903. #ifndef UNICAST_NOT_SUPPORTED
  904. case UNICASTFINDSRVTYPES:
  905. UnicastFindSrvTypes(&cmdline);
  906. break;
  907. #endif
  908. case FINDSCOPES:
  909. FindScopes(&cmdline);
  910. break;
  911. case GETPROPERTY:
  912. GetProperty(&cmdline);
  913. break;
  914. case REGISTER:
  915. Register(&cmdline);
  916. break;
  917. case DEREGISTER:
  918. Deregister(&cmdline);
  919. break;
  920. #ifndef MI_NOT_SUPPORTED
  921. case FINDSRVSUSINGIFLIST:
  922. FindSrvsUsingIFList(&cmdline);
  923. break;
  924. case FINDATTRSUSINGIFLIST:
  925. FindAttrsUsingIFList(&cmdline);
  926. break;
  927. case FINDSRVTYPESUSINGIFLIST:
  928. FindSrvTypesUsingIFList(&cmdline);
  929. break;
  930. #endif /* MI_NOT_SUPPORTED */
  931. case PRINT_VERSION:
  932. PrintVersion(&cmdline);
  933. break;
  934. case DUMMY:
  935. break;
  936. }
  937. }
  938. else
  939. {
  940. DisplayUsage();
  941. result = 1;
  942. }
  943. return 0;
  944. }