开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Telnet服务器 > 查看源码
plugutils.c
资源名称：nessus-libraries_2.2.10.orig.tar.gz　[点击查看]
上传用户：tjescc
上传日期：2021-02-23
资源大小：419k
文件大小：41k
源码类别：

Telnet服务器

开发平台：

Unix_Linux

plugutils.c：源码内容
  1. /* Nessuslib -- the Nessus Library
  2.  * Copyright (C) 1998 - 2003 Renaud Deraison
  3.  *
  4.  * This library is free software; you can redistribute it and/or
  5.  * modify it under the terms of the GNU Library General Public
  6.  * License as published by the Free Software Foundation; either
  7.  * version 2 of the License, or (at your option) any later version.
  8.  *
  9.  * This library is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12.  * Library General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU Library General Public
  15.  * License along with this library; if not, write to the Free
  16.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  *
  18.  * Plugutils -- plugin-specific stuff
  19.  */
  21. #define EXPORTING
  22. #include <includes.h>
  23. #include "comm.h"
  24. #include "harglists.h"
  25. #include "diff.h"
  26. #include "rand.h"
  27. #include "services.h"
  28. #include "store.h"
  30. /* want version stuff */
  31. #include "libvers.h"
  32. #include "scanners_utils.h"
  35. #undef DEBUG_DIFF_SCAN
  39. char *nessuslib_version()
  40. {
  41.   static char vers[255];
  42.   strncpy(vers, VERSION, sizeof(vers) - 1);
  43.   vers[sizeof(vers) - 1 ] = '';
  44.   return vers;
  45. }
  46. ExtFunc
  47. void nessus_lib_version(major, minor, rev)
  48.  int * major, *minor, *rev;
  49. {
  50.  *major = NL_MAJOR;
  51.  *minor = NL_MINOR;
  52.  *rev   = NL_REV;
  53. }
  55. #ifdef USE_PTHREADS
  56. ExtFunc 
  57. int nessuslib_pthreads_enabled()
  58. {
  59.  int enabled = 1;
  60.  return(enabled);
  61. }
  62. #endif
  68. /*
  69.  * Escapes n and r properly. The resulting string
  70.  * is copied in another buffer.
  71.  */
  72. ExtFunc char * 
  73. addslashes(in)
  74. char * in;
  75. {
  76.  char * ret;
  77.  char * out = malloc(strlen(in) * 2 + 1);
  78.  bzero(out, strlen(in) * 2 + 1);
  79.  ret = out;
  80.  while(in[0])
  81.  {
  82.   if(in[0] == '\')
  83.   {
  84.    out[0] = '\'; out++;
  85.    out[0] = '\'; out++;
  86.   }
  88.   else if(in[0] == 'n')
  89.   {
  90.    out[0] = '\'; out++;
  91.    out[0] = 'n'; out++;
  92.   }
  93.   else if(in[0] == 'r')
  94.   {
  95.     out[0] = '\'; out++;
  96.     out[0] = 'r';  out++;
  97.   }
  98.   else {
  99.   out[0] = in[0];
  100.   out++;
  101.   }
  102.   in++;
  103.  }
  104.  return realloc(ret, strlen(ret) + 1);
  105. }
  107. /*
  108.  * Replaces escape codes (n, r) by the real value
  109.  * The resulting string is stored in another buffer
  110.  */
  111. ExtFunc char * 
  112. rmslashes(in)
  113.  char * in;
  114. {
  115.  char * out = malloc(strlen(in) + 1);
  116.  char * ret = out;
  117.  bzero(out, strlen(in) + 1);
  118.  while(in[0])
  119.  {
  120.   if(in[0] == '\')
  121.   {
  122.    switch(in[1])
  123.    {
  124.     case 'r' :
  125.       out[0] = 'r';
  126.       in++;
  127.       break;
  128.     case 'n' :
  129.       out[0] =  'n';
  130.       in++;
  131.       break;
  132.     case '\' :
  133.       out[0] = '\';
  134.       in++;
  135.       break;
  136.     default :
  137.       fprintf(stderr, "Unknown escape sequence '\%c'n", in[1]);
  138.    }
  139.   }
  140.   else out[0] = in[0];
  141.   in++;
  142.   out++;
  143.  }
  144.  return realloc(ret, strlen(ret) + 1);
  145. }
  148. ExtFunc
  149. void plug_set_version(desc, version)
  150.  struct arglist * desc;
  151.  const char* version;
  152. {
  153.  arg_add_value(desc, "VERSION", ARG_STRING, strlen(version), estrdup((char*)version));
  154. }
  157. ExtFunc 
  158. char * _plug_get_version(desc)
  159.  struct arglist * desc;
  160. {
  161.  return arg_get_value(desc, "VERSION");
  162. }
  165. ExtFunc 
  166. char * plug_get_version(struct arglist * desc)
  167. {
  168.  return store_fetch_version(desc);
  169. }
  172. ExtFunc
  173. void plug_set_path(desc, path)
  174.  struct arglist * desc;
  175.  const char * path;
  176. {
  177.  arg_add_value(desc, "PATH", ARG_STRING, strlen(path), estrdup((char*)path));
  178. }
  180. ExtFunc 
  181. char * _plug_get_path(struct arglist * desc)
  182. {
  183.  return arg_get_value(desc, "PATH");
  184. }
  186. ExtFunc 
  187. char * plug_get_path(desc)
  188.  struct arglist * desc;
  189. {
  190.  return _plug_get_path(desc);
  191. }
  195. ExtFunc
  196. void plug_set_fname(desc, filename)
  197.  struct arglist * desc;
  198.  const char * filename;
  199. {
  200.  arg_add_value(desc, "FILENAME", ARG_STRING, strlen(filename), estrdup(filename));
  201. }
  203. ExtFunc 
  204. char * _plug_get_fname(struct arglist * desc)
  205. {
  206.  return arg_get_value(desc, "FILENAME");
  207. }
  209. ExtFunc 
  210. char * plug_get_fname(desc)
  211.  struct arglist * desc;
  212. {
  213.  return _plug_get_fname(desc);
  214. }
  217. ExtFunc
  218. void plug_set_id(desc, id)
  219.  struct arglist * desc;
  220.  int id;
  221. {
  222.  arg_add_value(desc, "ID", ARG_INT, sizeof(int), (void*)id);
  223. }
  225. ExtFunc int
  226. _plug_get_id(desc)
  227.  struct arglist * desc;
  228. {
  229.  return (int)arg_get_value(desc, "ID");
  230. }
  232. ExtFunc int
  233. plug_get_id(struct arglist * desc)
  234. {
  235.  return _plug_get_id(desc); /* Never cached */
  236. }
  239. ExtFunc
  240. void plug_set_cve_id(desc, id)
  241.  struct arglist * desc;
  242.  char * id;
  243. {
  244.  char * old = arg_get_value(desc, "CVE_ID");
  245.  if(old != NULL)
  246.  {
  247.   old = erealloc(old, strlen(old) + strlen(id) + 3);
  248.   strcat(old, ", ");
  249.   strcat(old, id);
  250.   arg_set_value(desc, "CVE_ID", strlen(old), old);
  251.  }
  252.  else
  253.   arg_add_value(desc, "CVE_ID", ARG_STRING, strlen(id), estrdup(id));
  254. }
  257. ExtFunc char *
  258. _plug_get_cve_id(desc)
  259.  struct arglist * desc;
  260. {
  261.  return arg_get_value(desc, "CVE_ID");
  262. }
  264. ExtFunc char * plug_get_cve_id(struct arglist * desc)
  265. {
  266.  return store_fetch_cve_id(desc);
  267. }
  270. ExtFunc
  271. void plug_set_bugtraq_id(desc, id)
  272.  struct arglist * desc;
  273.  char * id;
  274. {
  275.  char * old = arg_get_value(desc, "BUGTRAQ_ID");
  276.  if(old != NULL)
  277.  { 
  278.   old = erealloc(old, strlen(old) + strlen(id) + 3);
  279.   strcat(old, ", ");
  280.   strcat(old, id);
  281.   arg_set_value(desc, "BUGTRAQ_ID", strlen(old), old);
  282.  }
  283.  else
  284.   arg_add_value(desc, "BUGTRAQ_ID", ARG_STRING, strlen(id), estrdup(id));
  285. }
  287. ExtFunc char * _plug_get_bugtraq_id(desc)
  288.  struct arglist * desc;
  289. {
  290.  return arg_get_value(desc, "BUGTRAQ_ID");
  291. }
  293. ExtFunc char * plug_get_bugtraq_id(struct arglist * desc)
  294. {
  295.  return store_fetch_bugtraq_id(desc);
  296. }
  300. ExtFunc
  301. void plug_set_xref(desc,name, value)
  302.  struct arglist * desc;
  303.  char * name, * value;
  304. {
  305.  char * old = arg_get_value(desc, "XREFS");
  306.  if(old != NULL)
  307.  { 
  308.   old = erealloc(old, strlen(old) + strlen(name) + strlen(value) + 4);
  309.   strcat(old, ", ");
  310.   strcat(old, name);
  311.   strcat(old, ":");
  312.   strcat(old, value);
  313.   arg_set_value(desc, "XREFS", strlen(old), old);
  314.  }
  315.  else 
  316.   {
  317.   char * str;
  318.   
  319.   str = emalloc(strlen(name) + strlen(value) + 2);
  320.   strcat(str, name);
  321.   strcat(str, ":");
  322.   strcat(str, value);
  323.   arg_add_value(desc, "XREFS", ARG_STRING, strlen(str), str);
  324.   }
  325. }
  327. ExtFunc char * _plug_get_xref(desc)
  328.  struct arglist * desc;
  329. {
  330.  return arg_get_value(desc, "XREFS");
  331. }
  333. ExtFunc char * plug_get_xref(struct arglist * desc)
  334. {
  335.  return store_fetch_xref(desc);
  336. }
  340. ExtFunc
  341. void plug_set_family(desc, family, language)
  342.  struct arglist * desc; 
  343.  const char * family;
  344.  const char * language;
  345. {
  346.   char * s_language;
  347.   struct arglist * prefs = arg_get_value(desc, "preferences");
  348.   
  349.   s_language = arg_get_value(prefs,"language");
  350.   if(s_language && language)
  351.    {
  352.     if(!strcmp(s_language, language))
  353.     {
  354.     if(family)
  355.     arg_add_value(desc, "FAMILY", ARG_STRING,
  356.      strlen(family), estrdup(family));
  357.     }
  358.    }
  359.   else if(family)
  360.     {
  361.      if(!arg_get_value(desc, "FAMILY"))
  362.       arg_add_value(desc, "FAMILY", ARG_STRING,
  363.      strlen(family), estrdup(family));
  364.     }
  365. }
  368. ExtFunc
  369. char * _plug_get_family(desc)
  370.  struct arglist * desc;
  371. {
  372.  return arg_get_value(desc, "FAMILY");
  373. }
  375. ExtFunc
  376. char * plug_get_family(desc)
  377.  struct arglist * desc;
  378. {
  379.  return store_fetch_family(desc);
  380. }
  383. ExtFunc
  384. void plug_require_key(desc, keyname)
  385.  struct arglist * desc;
  386.  const char * keyname;
  387. {
  388.  struct arglist * keys;
  389.  if(keyname)
  390.  {
  391.   keys = arg_get_value(desc, "required_keys");
  392.   if(!keys)
  393.   {
  394.    keys = emalloc(sizeof(struct arglist));
  395.    arg_add_value(desc, "required_keys", ARG_ARGLIST, -1, keys);
  396.   }
  397.   arg_add_value(keys, keyname,  ARG_INT, 0, (void*)1);
  398.  }
  399. }
  401. ExtFunc 
  402. struct arglist * _plug_get_required_keys(desc)
  403.  struct arglist * desc;
  404. {
  405.  return arg_get_value(desc, "required_keys");
  406. }
  409. ExtFunc 
  410. struct arglist * plug_get_required_keys(desc)
  411.  struct arglist * desc;
  412. {
  413.  return _plug_get_required_keys(desc);
  414. }
  417. ExtFunc
  418. void plug_exclude_key(desc, keyname)
  419.  struct arglist * desc;
  420.  const char * keyname;
  421. {
  422.  struct arglist * keys;
  423.  if(keyname)
  424.  {
  425.   keys = arg_get_value(desc, "excluded_keys");
  426.   if(!keys)
  427.   {
  428.    keys = emalloc(sizeof(struct arglist));
  429.    arg_add_value(desc, "excluded_keys", ARG_ARGLIST, -1, keys);
  430.   }
  431.   arg_add_value(keys, keyname, ARG_INT, 0, (void*)1);
  432.  }
  433. }
  435. ExtFunc
  436. struct arglist * _plug_get_excluded_keys(desc)
  437.  struct arglist * desc;
  438. {
  439.  return arg_get_value(desc, "excluded_keys");
  440. }
  443. ExtFunc
  444. struct arglist * plug_get_excluded_keys(desc)
  445.  struct arglist * desc;
  446. {
  447.  return _plug_get_excluded_keys(desc);
  448. }
  450. ExtFunc 
  451. void plug_require_port(desc, portname)
  452.  struct arglist * desc;
  453.  const char * portname;
  454. {
  455.  struct arglist * ports;
  456.  
  457.  if(portname != NULL)
  458.  {
  459.   ports = arg_get_value(desc, "required_ports");
  460.   if(!ports)
  461.   {
  462.    ports = emalloc(sizeof(struct arglist));
  463.    arg_add_value(desc, "required_ports", ARG_ARGLIST, -1, ports);
  464.   }
  465.   
  466.   arg_add_value(ports, portname, ARG_INT, 0, (void*)1);
  467.  }
  468. }
  470. ExtFunc
  471. struct arglist * _plug_get_required_ports(desc)
  472.  struct arglist * desc;
  473. {
  474.  return arg_get_value(desc, "required_ports");
  475. }
  477. ExtFunc
  478. struct arglist * plug_get_required_ports(desc)
  479.  struct arglist * desc;
  480. {
  481.  return _plug_get_required_ports(desc);
  482. }
  485. ExtFunc 
  486. void plug_require_udp_port(desc, portname)
  487.  struct arglist * desc;
  488.  const char * portname;
  489. {
  490.  struct arglist * ports;
  491.  
  492.  if(portname != NULL)
  493.  {
  494.   ports = arg_get_value(desc, "required_udp_ports");
  495.   if(!ports)
  496.   {
  497.    ports = emalloc(sizeof(struct arglist));
  498.    arg_add_value(desc, "required_udp_ports", ARG_ARGLIST, -1, ports);
  499.   }
  500.   
  501.    arg_add_value(ports, portname, ARG_INT, 0, (void*)1);
  502.  }
  503. }
  505. ExtFunc 
  506. struct arglist * _plug_get_required_udp_ports(desc)
  507.  struct arglist * desc;
  508. {
  509.  return arg_get_value(desc, "required_udp_ports");
  510. }
  512. ExtFunc 
  513. struct arglist * plug_get_required_udp_ports(desc)
  514.  struct arglist * desc;
  515. {
  516.  return _plug_get_required_udp_ports(desc);
  517. }
  518.  
  521. ExtFunc
  522. void plug_set_dep(desc, depname)
  523.  struct arglist * desc;
  524.  const char * depname;
  525. {
  526.  struct arglist * deps;
  527.  if(depname)
  528.  {
  529.   deps = arg_get_value(desc, "DEPENDENCIES");
  530.   if(!deps){
  531.    deps = emalloc(sizeof(struct arglist));
  532.    arg_add_value(desc, "DEPENDENCIES", ARG_ARGLIST, -1, deps);
  533.    }
  534.   arg_add_value(deps, depname, ARG_STRING, 0, estrdup(""));
  535.  }
  536. }
  540. ExtFunc
  541. struct arglist * _plug_get_deps(desc)
  542.  struct arglist * desc;
  543. {
  544.  return arg_get_value(desc, "DEPENDENCIES");
  545. }
  548. ExtFunc
  549. struct arglist * plug_get_deps(desc)
  550.  struct arglist * desc;
  551. {
  552.  return _plug_get_deps(desc);
  553. #if 0
  554.  return store_fetch_dependencies(desc);
  555. #endif
  556. }
  558. ExtFunc
  559. void plug_set_timeout(desc, timeout)
  560.  struct arglist * desc; 
  561.  int timeout;
  562. {
  563.     arg_add_value(desc, "TIMEOUT", ARG_INT, sizeof(int), (void *)timeout);
  564. }
  567. ExtFunc
  568. int _plug_get_timeout(desc)
  569.  struct arglist * desc;
  570. {
  571.  return (int)arg_get_value(desc, "TIMEOUT");
  572. }
  575. ExtFunc
  576. int plug_get_timeout(desc)
  577.  struct arglist * desc;
  578. {
  579.  return _plug_get_timeout(desc);
  580. #if 0
  581.  return store_fetch_timeout(desc);
  582. #endif
  583. }
  587. ExtFunc
  588. void plug_set_launch(desc, launch)
  589.  struct arglist * desc;
  590.  int launch;
  591. {
  592.   if(arg_set_value(desc, "ENABLED", sizeof(int), (void *)launch))
  593.   {
  594.    arg_add_value(desc, "ENABLED", ARG_INT, sizeof(int), (void *)launch);
  595.   }
  596. }
  599. ExtFunc
  600. int plug_get_launch(desc)
  601.  struct arglist * desc;
  602. {
  603.   return((int)arg_get_value(desc, "ENABLED"));
  604. }
  607. ExtFunc
  608. void plug_set_name(desc, name, language)
  609.  struct arglist * desc; 
  610.  const char * name; 
  611.  const char * language;
  612. {
  613.  char * s_language;
  614.  struct arglist * prefs = arg_get_value(desc, "preferences");
  615.   
  616.   s_language = arg_get_value(prefs,"language");
  617.   if(s_language && language)
  618.    {
  619.     if(!strcmp(s_language, language))
  620.     {
  621.     if(name)
  622.     arg_add_value(desc, "NAME", ARG_STRING,
  623.      strlen(name), estrdup(name));
  624.     }
  625.    }
  626.   else if(name)
  627.   {
  628.     if(!arg_get_value(desc, "NAME"))
  629.      arg_add_value(desc, "NAME", ARG_STRING,
  630.      strlen(name), estrdup(name));
  631.   }
  632. }
  634. ExtFunc
  635. char * _plug_get_name(desc)
  636.  struct arglist * desc;
  637. {
  638.  return arg_get_value(desc, "NAME");
  639. }
  641. ExtFunc
  642. char * plug_get_name(desc)
  643.  struct arglist * desc;
  644. {
  645.  return _plug_get_name(desc);
  646.  /*return store_fetch_name(desc);*/
  647. }
  650. ExtFunc
  651. void plug_set_summary(desc, summary,language)
  652.  struct arglist * desc;
  653.  const char * summary;
  654.  const char * language;
  655. {
  656.  char * s_language;
  657.  struct arglist * prefs = arg_get_value(desc, "preferences");
  658.   
  659.   s_language = arg_get_value(prefs,"language");
  660.   if(s_language && language)
  661.    {
  662.     if(!strcmp(s_language, language))
  663.     {
  664.     if(summary)
  665.     arg_add_value(desc, "SUMMARY", ARG_STRING,
  666.      strlen(summary), estrdup(summary));
  667.     }
  668.    }
  669.   else if(summary)
  670.   {
  671.     if(!arg_get_value(desc, "SUMMARY"))
  672.      arg_add_value(desc, "SUMMARY", ARG_STRING,
  673.      strlen(summary), estrdup(summary));
  674.   }
  675. }
  677. ExtFunc
  678. char * _plug_get_summary(desc)
  679.  struct arglist * desc;
  680. {
  681.  return arg_get_value(desc, "SUMMARY");
  682. }
  684. ExtFunc
  685. char * plug_get_summary(desc)
  686.  struct arglist * desc;
  687. {
  688.  return store_fetch_summary(desc);
  689. }
  692. ExtFunc
  693. void plug_set_description(desc, description,language)
  694.  struct arglist * desc;
  695.  const char * description;
  696.  const char * language;
  697. {
  698.   char * s_language;
  699.  struct arglist * prefs = arg_get_value(desc, "preferences");
  700.   
  701.   s_language = arg_get_value(prefs,"language");
  702.   if(s_language && language)
  703.    {
  704.     if(!strcmp(s_language, language))
  705.     {
  706.     if(description)
  707.     arg_add_value(desc, "DESCRIPTION", ARG_STRING,
  708.      strlen(description), estrdup(description));
  709.     }
  710.    }
  711.   else if(description)
  712.   {
  713.     if(!arg_get_value(desc, "DESCRIPTION"))
  714.      arg_add_value(desc, "DESCRIPTION", ARG_STRING,
  715.      strlen(description), estrdup(description));
  716.   }
  717. }
  720. ExtFunc
  721. char * _plug_get_description(desc)
  722.  struct arglist * desc;
  723. {
  724.  return arg_get_value(desc, "DESCRIPTION");
  725. }
  727. ExtFunc
  728. char * plug_get_description(desc)
  729.  struct arglist * desc;
  730. {
  731.  return store_fetch_description(desc);
  732. }
  735. ExtFunc
  736. void plug_set_copyright(desc, copyright,language)
  737.  struct arglist * desc;
  738.  const char * copyright;
  739.  const char * language;
  740. {
  741.  char * s_language;
  742.  struct arglist * prefs = arg_get_value(desc, "preferences");
  743.   
  744.   s_language = arg_get_value(prefs,"language");
  745.   if(s_language && language)
  746.    {
  747.     if(!strcmp(s_language, language))
  748.     {
  749.     if(copyright)
  750.     arg_add_value(desc, "COPYRIGHT", ARG_STRING,
  751.      strlen(copyright), estrdup(copyright));
  752.     }
  753.    }
  754.   else if(copyright)
  755.   {
  756.     if(!arg_get_value(desc, "COPYRIGHT"))
  757.      arg_add_value(desc, "COPYRIGHT", ARG_STRING,
  758.      strlen(copyright), estrdup(copyright));
  759.   }
  760. }
  762. ExtFunc
  763. char * _plug_get_copyright(desc)
  764.  struct arglist * desc;
  765. {
  766.  return arg_get_value(desc, "COPYRIGHT");
  767. }
  770. ExtFunc
  771. char * plug_get_copyright(desc)
  772.  struct arglist * desc;
  773. {
  774.  return store_fetch_copyright(desc);
  775. }
  778. ExtFunc
  779. void plug_set_category(desc, category)
  780.  struct arglist * desc;
  781.  int category;
  782. {
  783.        arg_add_value(desc, "CATEGORY", ARG_INT, sizeof(int), (void *)category);
  784. }
  786. ExtFunc
  787. int _plug_get_category(desc)
  788.  struct arglist * desc;
  789. {
  790.  return (int)arg_get_value(desc, "CATEGORY"); /* We don't cache this one */
  791. }
  793. ExtFunc
  794. int plug_get_category(desc)
  795.  struct arglist * desc;
  796. {
  797.  return _plug_get_category(desc);
  798. }
  802. ExtFunc
  803. void plug_add_host(desc, hostname)
  804.  struct arglist * desc;
  805.  struct arglist * hostname;
  806. {
  807. struct arglist * h;
  809. h = arg_get_value(desc, "HOSTNAME");
  810. if(!h)arg_add_value(desc, "HOSTNAME", ARG_ARGLIST, sizeof(hostname), hostname);
  811. else arg_set_value(desc, "HOSTNAME", sizeof(hostname), hostname);
  812. }
  815. ExtFunc
  816. void host_add_port_proto(args, portnum, state, proto)
  817.  struct arglist * args;
  818.  int portnum;
  819.  int state;
  820.  char * proto;
  821. {
  822.  char port_s[255];
  823.  
  824.  snprintf(port_s, sizeof(port_s), "Ports/%s/%d", proto, portnum);
  825.  plug_set_key(args, port_s, ARG_INT, (void*)1);
  826. }
  829. ExtFunc
  830. void host_add_port(hostdata, portnum, state)
  831.  struct arglist * hostdata;
  832.  int portnum;
  833.  int state;
  834. {
  835.  host_add_port_proto(hostdata, portnum, state, "tcp");
  836. }
  838. ExtFunc
  839. void host_add_port_udp(hostdata, portnum, state)
  840.  struct arglist * hostdata;
  841.  int portnum;
  842.  int state;
  843. {
  844.  host_add_port_proto(hostdata, portnum, state, "udp");
  845. }
  846.   
  848. int port_in_ports(port, ports, s, e)
  849. u_short port, * ports;
  850. int s, e;
  851. {
  852.  int mid = (s+e)/2;
  853.  if(s==e)return(port == ports[e]);
  854.  if(port > ports[mid])return(port_in_ports(port, ports, mid+1, e));
  855.  else return(port_in_ports(port, ports, s, mid));
  856. }
  857.  
  860. static int
  861. unscanned_ports_as_closed(prefs)
  862.  struct arglist * prefs;
  863. {
  864.  char * unscanned;
  865.  unscanned = arg_get_value(prefs, "unscanned_closed");
  866.  if(unscanned && !strcmp(unscanned, "yes"))
  867.   return 0;
  868.  else
  869.   return 1;
  870. }
  871.            
  872. ExtFunc
  873. int kb_get_port_state_proto(kb, prefs, portnum, proto)
  874.  struct kb_item ** kb;
  875.  struct arglist * prefs;
  876.  int portnum;
  877.  char * proto;
  878. { 
  879.  char port_s[255];
  880.  unsigned short * range;
  881.  char * prange = (char*)arg_get_value(prefs, "port_range");
  882.  int num;
  884.  if(!proto)
  885.   proto = "tcp";
  886.   
  887.  /* Check that we actually scanned the port */
  888.  
  889.  if(!strcmp(proto, "tcp") && kb_item_get_int(kb, "Host/scanned") <= 0){
  890. return unscanned_ports_as_closed(prefs);
  891. }
  893.  else if(!strcmp(proto, "udp") && kb_item_get_int(kb, "Host/udp_scanned") <= 0)
  894.        {
  895.         return 1;
  896.       }
  897.       
  898.       
  899.  range = (u_short*)getpts(prange, &num);
  901.  if( range == NULL ){
  902.   return(1);
  903. }
  905.  if(!port_in_ports(portnum, range, 0, num)){
  906.        return unscanned_ports_as_closed(prefs);
  907.        }
  908.  
  909.  /* Ok, we scanned it. What is its state ? */
  910.  
  911.  snprintf(port_s, sizeof(port_s), "Ports/%s/%d", proto, portnum);
  912.  if(kb_item_get_int(kb, port_s) > 0 )
  913.     return 1;
  914.   else
  915.    return 0;
  916. }
  918. ExtFunc
  919. int host_get_port_state_proto(plugdata, portnum, proto)
  920.  struct arglist * plugdata;
  921.  int portnum;
  922.  char * proto;
  923. { 
  924.  struct kb_item ** kb = plug_get_kb(plugdata);
  925.  struct arglist * prefs = arg_get_value(plugdata, "preferences");
  926.  
  927.  return kb_get_port_state_proto(kb, prefs, portnum, proto);
  928. }
  930. ExtFunc
  931. int host_get_port_state(plugdata, portnum)
  932.  struct arglist * plugdata;
  933.  int portnum;
  934. {
  935.  return(host_get_port_state_proto(plugdata, portnum, "tcp"));
  936. }
  938. ExtFunc
  939. int host_get_port_state_udp(plugdata, portnum)
  940.  struct arglist * plugdata;
  941.  int portnum;
  942. {
  943.  return(host_get_port_state_proto(plugdata, portnum, "udp"));
  944. }
  947. ExtFunc
  948. const char * plug_get_hostname(desc)
  949.  struct arglist * desc;
  950. {
  951.  struct arglist * hinfos = arg_get_value(desc, "HOSTNAME");
  952.  if(hinfos)return((char*)arg_get_value(hinfos, "NAME"));
  953.  else return(NULL);
  954. }
  956. ExtFunc
  957. const char * plug_get_host_fqdn(desc)
  958.  struct arglist * desc;
  959. {
  960.  struct arglist * hinfos = arg_get_value(desc, "HOSTNAME");
  961.  if(hinfos)return((char*)arg_get_value(hinfos, "FQDN"));
  962.  else return(NULL);
  963. }
  966. ExtFunc
  967. struct in_addr * plug_get_host_ip(desc)
  968.  struct arglist * desc;
  969. {
  970.  struct arglist * hinfos = arg_get_value(desc, "HOSTNAME");
  971.  if(hinfos)return((struct in_addr*)arg_get_value(hinfos, "IP"));
  972.  else return(NULL);
  973. }
  977. static void 
  978. mark_successful_plugin(desc)
  979.  struct arglist * desc;
  980. {
  981.  int id = plug_get_id(desc);
  982.  char data[512];
  983.  
  985.  bzero(data, sizeof(data));
  986.  snprintf(data, sizeof(data), "Success/%d", id);
  987.  plug_set_key(desc, data, ARG_INT,(void*)1);
  988. }
  990. static void
  991. mark_post(desc, action, content)
  992.  struct arglist * desc;
  993.  char * action;
  994.  char * content;
  995. {
  996.  char entry_name[255];
  997.  
  998.  if(strlen(action) > (sizeof(entry_name) - 20))
  999.   return;
  1000.   
  1001.  snprintf(entry_name, sizeof(entry_name), "SentData/%d/%s", plug_get_id(desc), action);
  1002.  plug_set_key(desc, entry_name, ARG_STRING, content);
  1003. }
  1005.  
  1006.  
  1007. /* Pluto 24.6.00: reduced to one, and left the orig in place */
  1008. void 
  1009. proto_post_wrapped(desc, port, proto, action, what)
  1010.  struct arglist * desc;
  1011.  int port;
  1012.  const char * proto;
  1013.  const char * action;
  1014.  const char * what;
  1015. {
  1017.  char *t;
  1018.  char * buffer;
  1019.  int soc;
  1020.  char * naction;
  1021.  int len;
  1022.  ntp_caps* caps = arg_get_value(desc, "NTP_CAPS");
  1023.  char * cve;
  1024.  char * bid;
  1025.  char * xref;
  1026.  int do_send = 1;
  1027.  int i;
  1028.  char ack;
  1029.  int n = 0, e, l;
  1030.   
  1031.     
  1032.  if( action == NULL )action = plug_get_description(desc);
  1033.  
  1034.  
  1035.  cve = plug_get_cve_id(desc);
  1036.  bid = plug_get_bugtraq_id(desc);
  1037.  xref = plug_get_xref(desc);
  1038.  
  1039.  if( action == NULL )
  1040.   return;
  1043.  len = strlen(action) + 1;
  1044.  if(cve != NULL)
  1045.   len += strlen(cve) + 20;
  1047.  if(bid != NULL)
  1048.    len += strlen(bid) + 20;
  1050.  if(xref != NULL )
  1051.   len += strlen(xref) + 20;
  1053.  if( caps == NULL )
  1054.   return;
  1056.  
  1057.  naction = emalloc(len+1);
  1058.  strncpy(naction, action, strlen(action));
  1059.  strcat(naction, "n");
  1060.  if( cve != NULL && cve[0] != '')
  1061.         {
  1062.  strcat(naction, "CVE : ");
  1063.  strcat(naction, cve);
  1064.  strcat(naction, "n");
  1065.  }
  1066.  
  1067.  if( bid != NULL && bid[0] != '' )
  1068.   {
  1069.  strcat(naction, "BID : ");
  1070.  strcat(naction, bid);
  1071.  strcat(naction, "n");
  1072.  }
  1073.  if( xref != NULL && xref[0] != '' )
  1074.   {
  1075. strcat(naction, "Other references : ");
  1076. strcat(naction, xref);
  1077. strcat(naction, "n");
  1078. }
  1079.  
  1080.  if( caps->escape_crlf == 0 )
  1081.    while((t=strchr(naction, 'n'))||(t=strchr(naction, 'r')))t[0]=';';
  1082.  else
  1083.   {
  1084.    char * old = naction;
  1085.    len -= strlen(naction);
  1086.    naction = addslashes(naction);
  1087.    len += strlen(naction);
  1088.    efree(&old);
  1089.   }
  1090.   
  1091.  for(i=0;naction[i];i++)
  1092.  {
  1093.    if(!isprint(naction[i]))
  1094.       naction[i] = ' ';
  1095.  }
  1098.  buffer = emalloc( 1024 + len );
  1099.  if(caps->ntp_11) {
  1100.    char idbuffer[32];
  1101.    const char *svc_name = nessus_get_svc_name(port, proto);
  1102.    if (caps->scan_ids) { 
  1103.      if (plug_get_id(desc) == 0) {
  1104.        *idbuffer = '';
  1105.      } else {
  1106.        int id = plug_get_id(desc);
  1107.        snprintf(idbuffer, sizeof(idbuffer), "<|> %d ", id);
  1108.      }
  1109.    } else {
  1110.      *idbuffer = '';
  1111.  }
  1112.   if(port>0){
  1113.      snprintf(buffer, 1024 + len, 
  1114.      "SERVER <|> %s <|> %s <|> %s (%d/%s) <|> %s %s<|> SERVERn",
  1115.      what,
  1116.         plug_get_hostname(desc),
  1117.      svc_name,
  1118.      port, proto, naction, idbuffer);
  1119.     
  1120.    } else
  1121.      snprintf(buffer, 1024 + len, 
  1122.      "SERVER <|> %s <|> %s <|> general/%s <|> %s %s<|> SERVERn",
  1123.      what,
  1124.         plug_get_hostname(desc), 
  1125.      proto, naction, idbuffer);
  1126.  } else {
  1127.    snprintf(buffer, 1024 + len, "SERVER <|> %s <|> %s <|> %d:%s <|> SERVERn", 
  1128.    what,
  1129.    plug_get_hostname(desc), port, naction);
  1130.  }
  1131.  
  1132.  
  1134. mark_post(desc, what, action); 
  1135. soc = (int)arg_get_value(desc, "SOCKET");
  1136. internal_send(soc, buffer, INTERNAL_COMM_MSG_TYPE_DATA);
  1137.  
  1138.  /*
  1139.   * Mark in the KB that the plugin was sucessful
  1140.   */
  1141.  mark_successful_plugin(desc);
  1142.  efree(&buffer);
  1143.  efree(&naction);
  1144.  return;
  1145. }
  1147. /* Pluto end */
  1149. ExtFunc
  1150. void proto_post_hole(desc, port, proto, action)
  1151.  struct arglist * desc;
  1152.  int port;
  1153.  const char * proto;
  1154.  const char * action;
  1155. {
  1156.   proto_post_wrapped(desc, port, proto, action, "HOLE");
  1157.   return;
  1158. }
  1161. ExtFunc
  1162. void post_hole(desc, port, action)
  1163.  struct arglist * desc;
  1164.  int port;
  1165.  const char * action;
  1166. {
  1167.   proto_post_hole(desc, port, "tcp", action);
  1168. } 
  1171. ExtFunc
  1172. void post_hole_udp(desc, port, action)
  1173.  struct arglist * desc;
  1174.  int port;
  1175.  const char * action;
  1176. {
  1177.  proto_post_hole(desc, port, "udp", action);
  1178. }
  1181. ExtFunc
  1182. void post_info(desc, port, action)
  1183.  struct arglist * desc;
  1184.  int port;
  1185.  const char * action;
  1186. {
  1187.   proto_post_info(desc, port, "tcp", action);
  1188. } 
  1191. ExtFunc
  1192. void post_info_udp(desc, port, action)
  1193.  struct arglist * desc;
  1194.  int port;
  1195.  const char * action;
  1196. {
  1197.  proto_post_info(desc, port, "udp", action);
  1198. }
  1201. ExtFunc
  1202. void proto_post_info(desc, port, proto, action)
  1203.  struct arglist * desc;
  1204.  int port;
  1205.  const char * proto;
  1206.  const char * action;
  1207. {
  1208.   proto_post_wrapped(desc, port, proto, action, "INFO");
  1209.   return;
  1210. }
  1211.  
  1212. ExtFunc
  1213. void post_note(desc, port, action)
  1214.  struct arglist * desc;
  1215.  int port;
  1216.  const char * action;
  1217. {
  1218. #if 0
  1219.   fprintf(stderr, "Post_note: port = %d action = %sn", port, action);
  1220. #endif
  1221.   proto_post_note(desc, port, "tcp", action);
  1222. } 
  1224.      
  1225. ExtFunc
  1226. void post_note_udp(desc, port, action)
  1227.  struct arglist * desc;
  1228.  int port;
  1229.  const char * action;
  1230. {
  1231.  proto_post_note(desc, port, "udp", action);
  1232. }
  1233.    
  1235. ExtFunc
  1236. void proto_post_note(desc, port, proto, action)
  1237.  struct arglist * desc;
  1238.  int port;
  1239.  const char * proto;
  1240.  const char * action;
  1241. {
  1242.   /*
  1243.    * Backward compatibility. We only use the notes if the remote
  1244.    * client accepts them
  1245.    */
  1246.   char * allow_notes = get_preference(desc, "ntp_client_accepts_notes");
  1247.   if(allow_notes && !strcmp(allow_notes, "yes")) 
  1248.    proto_post_wrapped(desc, port, proto, action, "NOTE");
  1249.   else
  1250.    proto_post_wrapped(desc, port, proto, action, "INFO");
  1251.  return;
  1252. } 
  1253.  
  1254.  
  1255. ExtFunc
  1256. char * get_preference(desc, name)
  1257.  struct arglist *desc;
  1258.  const char * name;
  1259. {
  1260.  struct arglist * prefs;
  1261.  prefs = arg_get_value(desc, "preferences");
  1262.  if(!prefs)return(NULL);
  1263.  return((char *)arg_get_value(prefs, name));
  1264. }
  1267. ExtFunc
  1268. void _add_plugin_preference(prefs, p_name, name, type, defaul)
  1269.  struct arglist *prefs;
  1270.  const char * p_name;
  1271.  const char * name;
  1272.  const char * type;
  1273.  const char * defaul;
  1274. {
  1275.  char * pref;
  1276.  char * cname;
  1277.  int len;
  1278.  
  1279.  
  1280.  
  1281.  cname = estrdup(name);
  1282.  len = strlen(cname);
  1283.  while(cname[len-1]==' ')
  1284.  {
  1285.   cname[len-1]='';
  1286.   len --;
  1287.  }
  1288.  if(!prefs || !p_name)
  1289.    {
  1290.      efree(&cname);
  1291.      return;
  1292.    }
  1295.  pref = emalloc(strlen(p_name)+10+strlen(type)+strlen(cname));
  1296.  sprintf(pref, "%s[%s]:%s", p_name, type, cname);
  1297.  if ( arg_get_value(prefs, pref) == NULL )
  1298.   arg_add_value(prefs, pref, ARG_STRING, strlen(defaul), estrdup(defaul));
  1300.  efree(&cname);
  1301.  efree(&pref);
  1302. }
  1304. void add_plugin_preference(desc, name, type, defaul)
  1305.  struct arglist *desc;
  1306.  const char * name;
  1307.  const char * type;
  1308.  const char * defaul;
  1309. {
  1310.  struct arglist * prefs = arg_get_value(desc, "PLUGIN_PREFS");
  1311.  char pref[1024];
  1312.  
  1313.  
  1314.  if(prefs == NULL)
  1315.   {
  1316.    prefs = emalloc(sizeof(struct arglist));
  1317.    arg_add_value(desc, "PLUGIN_PREFS", ARG_ARGLIST, -1, prefs);
  1318.   }
  1319.  
  1321.  snprintf(pref, sizeof(pref), "%s/%s", type, name);
  1322.  arg_add_value(prefs, pref, ARG_STRING, strlen(defaul), estrdup(defaul));
  1323. }
  1327. ExtFunc char * 
  1328. get_plugin_preference(desc, name)
  1329.   struct arglist * desc;
  1330.   const char * name;
  1331. {
  1332.  struct arglist * prefs = arg_get_value(desc, "preferences");
  1333.  char * plug_name = plug_get_name(desc);
  1334.  char * cname = estrdup(name);
  1335.  int len;
  1336.  
  1337.  len = strlen(cname);
  1338.  
  1339.  while(cname[len-1]==' ')
  1340.  {
  1341.   cname[len-1]='';
  1342.   len --;
  1343.  }
  1344.  
  1345.  
  1346.  if(!prefs)
  1347.    {
  1348.      efree(&cname);
  1349.      return NULL;
  1350.    }
  1351.   
  1352.  while(prefs->next)
  1353.  {
  1354.   char * a= NULL, *b = NULL;
  1355.   int c = 0;
  1356.   char * t = prefs->name;
  1357.   
  1358.   a = strchr(t, '[');
  1359.   if(a)b=strchr(t, ']');
  1360.   if(b)c=(b[1]==':');
  1361.   
  1362.   if(c)
  1363.   {
  1364.    b+=2*sizeof(char);
  1365.    if(!strcmp(cname, b)){
  1366.     int old = a[0];
  1367.     a[0] = 0;
  1368. if(!strcmp(t, plug_name)){
  1369. a[0] = old;
  1370. efree(&cname);
  1371. return(prefs->value);
  1372. }
  1373. a[0] = old;
  1374. }
  1375.   }
  1376.   prefs = prefs->next;
  1377.  }
  1378.  efree(&cname);
  1379.  return(NULL);
  1380. }
  1382. ExtFunc const char * 
  1383. get_plugin_preference_fname(desc, filename)
  1384.  struct arglist * desc;
  1385.  const char * filename;
  1386. {
  1387.  struct arglist * globals = arg_get_value(desc, "globals");
  1388.  harglst * trans;
  1389.  if(!globals) 
  1390.   return NULL;
  1391.   
  1392.  trans = arg_get_value(globals, "files_translation");
  1393.  if(!trans)
  1394.   return NULL;
  1395.  
  1396.  return harg_get_string(trans, filename);
  1397. }
  1400. void * plug_get_fresh_key(args, name, type)
  1401.  struct arglist * args;
  1402.  char * name;
  1403.  int * type;
  1404. {
  1405.  struct arglist * globals = arg_get_value(args, "globals");
  1406.  int soc = (int)arg_get_value(globals, "global_socket");
  1407.  int e;
  1408.  char * buf = NULL;
  1409.  int bufsz = 0;
  1410.  int msg;
  1411.  
  1412.  if ( name == NULL || type == NULL ) return NULL;
  1413.  *type = -1;
  1415.  e = internal_send(soc, name, INTERNAL_COMM_MSG_TYPE_KB|INTERNAL_COMM_KB_GET);
  1416.  if(e < 0){
  1417.         fprintf(stderr, "[%d] plug_get_fresh_key:internal_send(%d): %sn",getpid(), soc,name, strerror(errno));
  1418. goto err;
  1419. }
  1421.  internal_recv(soc, &buf, &bufsz, &msg); 
  1422.  if ( ( msg & INTERNAL_COMM_MSG_TYPE_KB ) == 0  )
  1423.  {
  1424.         fprintf(stderr, "[%d] plug_get_fresh_key:internal_send(%d): Unexpected message %d",getpid(), soc, msg);
  1425. goto err;
  1426.  }
  1428.  if ( msg & INTERNAL_COMM_KB_ERROR ) return NULL;
  1429.  if ( msg & INTERNAL_COMM_KB_SENDING_STR )
  1430.  {
  1431.   char * ret = estrdup(buf);
  1432.   *type = ARG_STRING;
  1433.   efree(&buf);
  1434.   return ret;
  1435.  } 
  1436.  else if ( msg & INTERNAL_COMM_KB_SENDING_INT )
  1437.  {
  1438.   int ret;
  1439.   *type = ARG_INT;
  1440.   ret = atoi(buf);
  1441.   efree(&buf);
  1442.   return (void*)ret;
  1443.  }
  1444. err:
  1445.  if ( buf != NULL )efree(&buf);
  1446.  return NULL; 
  1447. } 
  1449. static void plug_set_replace_key(args, name, type, value, replace)
  1450.  struct arglist * args;
  1451.  char * name;
  1452.  int type;
  1453.  void * value;
  1454.  int replace;
  1455. {
  1456.  struct kb_item ** kb = plug_get_kb(args);
  1457.  struct arglist * globals = arg_get_value(args, "globals");
  1458.  int soc = (int)arg_get_value(globals, "global_socket");
  1459.  char * str = NULL;
  1460.  int msg;
  1461.  
  1462.  
  1463. #ifdef DEBUG
  1464.  printf("set key %s -> %dn", name, value);
  1465. #endif 
  1466.  
  1467.  if( name == NULL || value == NULL )return;
  1468.  
  1469.  switch(type)
  1470.  {
  1471.   case ARG_STRING :
  1472.    kb_item_add_str(kb, name, value);
  1473.    value = addslashes(value);
  1474.    str = emalloc(strlen(name)+strlen(value)+10);
  1475.    sprintf(str, "%d %s=%s;n", ARG_STRING, name, (char *)value);
  1476.    efree(&value);
  1477.    break;
  1478.   case ARG_INT :
  1479.    kb_item_add_int(kb, name, (int)value);
  1480.    str = emalloc(strlen(name)+20);
  1481.    sprintf(str, "%d %s=%d;n", ARG_INT, name, (int)value);
  1482.    break;
  1483.  }
  1484.  if(str)
  1485.  {
  1486.    int e;
  1487.    if ( replace != 0 )
  1488.     msg = INTERNAL_COMM_MSG_TYPE_KB|INTERNAL_COMM_KB_REPLACE;
  1489.    else
  1490.     msg = INTERNAL_COMM_MSG_TYPE_KB;
  1492.    e = internal_send(soc, str, msg);
  1493.     if(e < 0){
  1494.         fprintf(stderr, "[%d] plug_set_key:internal_send(%d)['%s']: %sn",getpid(), soc,str, strerror(errno));
  1495. }
  1496.    efree(&str);
  1497.   }
  1498. } 
  1501. ExtFunc void plug_set_key(args, name, type, value)
  1502.  struct arglist * args;
  1503.  char * name;
  1504.  int type;
  1505.  void * value;
  1506. {
  1507.  plug_set_replace_key(args, name, type, value, 0);
  1508. }
  1511. ExtFunc void plug_replace_key(args, name, type, value)
  1512.  struct arglist * args;
  1513.  char * name;
  1514.  int type;
  1515.  void * value;
  1516. {
  1517.  plug_set_replace_key(args, name, type, value, 1);
  1518. }
  1519. ExtFunc void
  1520. scanner_add_port(args, port, proto)
  1521.  struct arglist * args;
  1522.  int port;
  1523.  char * proto;
  1524. {
  1525.  ntp_caps* caps = arg_get_value(args, "NTP_CAPS");
  1526.  char * buf;
  1527.  const char *svc_name = nessus_get_svc_name(port, proto);
  1528.  const char * hn = plug_get_hostname(args);
  1529.  int len;
  1530.  int soc;
  1531.  struct arglist * globs;
  1532.  int do_send = 1;
  1533.  static int confirm = -1;
  1534.  
  1535.  if(confirm < 0)
  1536.  {
  1537.   struct arglist * globals = arg_get_value(args, "globals");
  1538.   if(globals)confirm = (int)arg_get_value(globals, "confirm");
  1539.  }
  1541.  /*
  1542.   * Diff scan stuff : if the port was known to be open,
  1543.   * there is no need to report it again.
  1544.   */
  1545.  if(arg_get_value(args, "DIFF_SCAN"))
  1546.  {
  1547.    char port_s[255];
  1548.    snprintf(port_s, sizeof(port_s), "Ports/%s/%d", proto, port);
  1549.    if(kb_item_get_int(plug_get_kb(args), port_s) > 0) do_send = 0;
  1550.  }
  1553.  host_add_port_proto(args, port, 1, proto);
  1554.  
  1555.  len = 255 + (hn ? strlen(hn):0) + strlen(svc_name);
  1556.  buf = emalloc(len);
  1557.  if(caps != NULL && caps->ntp_11)
  1558.   snprintf(buf, len, "SERVER <|> PORT <|> %s <|> %s (%d/%s) <|> SERVERn",
  1559.   hn,svc_name, port, proto);
  1560.  else
  1561.   {
  1562.    if(!strcmp(proto, "tcp"))
  1563.      snprintf(buf, len, "SERVER <|> PORT <|> %s <|> %d <|> SERVERn",
  1564.    hn, port);
  1565.   }
  1566.    
  1567.  if(do_send)
  1568.  {
  1569.   soc = (int)arg_get_value(args, "SOCKET");
  1570.   internal_send(soc, buf, INTERNAL_COMM_MSG_TYPE_DATA);
  1571.  }
  1572.  efree(&buf);
  1573. }
  1577. struct kb_item ** plug_get_kb(struct arglist * args)
  1578. {
  1579.  return (struct kb_item**)arg_get_value(args, "key");
  1580. } 
  1582. /*
  1583.  * plug_get_key() may fork(). We use this signal handler to kill
  1584.  * its son in case the process which calls this function is killed
  1585.  * itself
  1586.  */
  1587. #ifndef NESSUSNT
  1588. static int _plug_get_key_son = 0;
  1590. static void 
  1591. plug_get_key_sighand_term(int sig)
  1592. {
  1593.  int son = _plug_get_key_son;
  1594.  
  1595.  if(son != 0)
  1596.  {
  1597.   kill(son, SIGTERM);
  1598.   _plug_get_key_son = 0;
  1599.  }
  1600.  _exit(0);
  1601. }
  1603. static void
  1604. plug_get_key_sigchld(int sig)
  1605. {
  1606.  int status;
  1607.  wait(&status);
  1608. }
  1610. static void
  1611. sig_n(int signo, void (*fnc)(int) )
  1612. {
  1613.  #ifdef HAVE_SIGACTION
  1614.   struct sigaction sa;
  1615.   sa.sa_handler = fnc;
  1616.   sa.sa_flags = 0;
  1617.   sigemptyset(&sa.sa_mask);
  1618.   sigaction(signo, &sa, (struct sigaction *) 0);
  1619. #else
  1620.   signal(signo, fnc);
  1621. #endif
  1622. }
  1624. static void
  1625. sig_term( void (*fcn)(int) )
  1626. {
  1627.  sig_n(SIGTERM, fcn);
  1628. }
  1630. static void
  1631. sig_alarm( void (*fcn)(int) )
  1632. {
  1633.  sig_n(SIGALRM, fcn);
  1634. }
  1636. static void 
  1637. sig_chld( void(*fcn)(int) )
  1638. {
  1639.  sig_n(SIGCHLD, fcn);
  1640. }
  1641. #endif
  1644. void * 
  1645. plug_get_key(args, name, type)
  1646.  struct arglist * args;
  1647.  char * name;
  1648.  int * type;
  1649. {
  1650.  struct kb_item ** kb = plug_get_kb(args);
  1651.  struct kb_item * res = NULL;
  1652.  int sockpair[2];
  1653.  int upstream = 0;
  1654.  char * buf = NULL;
  1655.  int bufsz = 0;
  1656.  
  1657.  
  1658.  if ( type != NULL )
  1659. *type = -1;
  1660.  
  1661.  
  1662.  if( kb == NULL )
  1663.     return NULL;
  1665.  res = kb_item_get_all(kb, name);
  1666.  
  1667.  if ( res == NULL ) 
  1668.     return NULL;
  1670.  if ( res->next == NULL ) /* No fork - good */
  1671.  {
  1672.   void * ret;
  1673.   if(res->type == KB_TYPE_INT)
  1674.     {
  1675.     if( type != NULL ) *type = ARG_INT;
  1676.     ret   = (void*)res->v.v_int;
  1677.     }
  1678.   else
  1679.     {
  1680.     if(type != NULL)*type = ARG_STRING;
  1681.     ret   = (void*)res->v.v_str;
  1682.     } 
  1683.   kb_item_get_all_free(res);
  1684.   return ret;
  1685.  }
  1686.  
  1687.  
  1688.  /* More than  one value - we will fork() then */
  1689.  sig_chld(plug_get_key_sigchld);
  1690.  while( res != NULL )
  1691.  {
  1692.   pid_t pid;
  1693.   socketpair(AF_UNIX, SOCK_STREAM, 0, sockpair);
  1694.   if ( (pid = fork()) == 0 )
  1695.   {
  1696.    int tictac = 0;
  1697.    int old, soc;
  1698.    struct arglist * globals, * preferences = NULL;
  1699.   
  1700.    close(sockpair[0]);  
  1701.    globals = arg_get_value(args, "globals");  
  1702.    old = (int)arg_get_value(globals, "global_socket");
  1703.    close(old);
  1704.    soc = dup2(sockpair[1], 4);
  1705.    close(sockpair[1]);
  1706.    arg_set_value(globals, "global_socket", sizeof(int), (void*)soc);
  1707.    arg_set_value(args, "SOCKET", sizeof(int), (void*)soc);
  1709.    if ( globals != NULL ) preferences = arg_get_value(globals, "preferences");
  1710.    if ( preferences != NULL )
  1711.    { 
  1712.     char * to = arg_get_value(preferences, "plugins_timeout");
  1713.     if ( to != NULL )  tictac = atoi(to);
  1714.    }
  1716.    srand48(getpid() + getppid() + time(NULL));
  1717.  
  1718.    sig_term(_exit);
  1719.    sig_alarm(_exit);
  1720.    alarm(120);
  1723.    if ( res->type == KB_TYPE_INT )
  1724.    {
  1725.     int old_value = res->v.v_int;
  1726.      kb_item_rm_all(kb, name); 
  1727.      kb_item_add_int(kb, name, old_value);
  1728.     if ( type != NULL )*type = ARG_INT;
  1729.     return (void*)old_value;
  1730.    }
  1731.    else
  1732.    {
  1733.     char * old_value = estrdup(res->v.v_str);
  1734.     kb_item_rm_all(kb, name); 
  1735.     kb_item_add_str(kb, name, old_value);
  1736.     if ( type != NULL ) *type = ARG_STRING;
  1737.     efree(&old_value);
  1738.     return kb_item_get_str(kb, name);
  1739.    }
  1740.   }
  1741.   else if(pid < 0)
  1742.       {
  1743.        fprintf(stderr, "nessus-libraries:libnessus:plugutils.c:plug_get_key(): fork() failed : %s", strerror(errno));       
  1744.        return NULL;
  1745.       }
  1746.   else
  1747.       {
  1748.       int e;
  1749.       int status;
  1750.       struct arglist * globals, * preferences = NULL;
  1751.   
  1752.       globals = arg_get_value(args, "globals");  
  1753.       upstream = (int)arg_get_value(globals, "global_socket");
  1754.       close(sockpair[1]);
  1755.       _plug_get_key_son = pid;
  1756.       sig_term(plug_get_key_sighand_term);
  1757.       for(;;)
  1758.       {
  1759.       fd_set rd;
  1760.       struct timeval tv;
  1761.       int type;
  1762.       do {
  1763.       tv.tv_sec = 0;
  1764.       tv.tv_usec = 100000;
  1765.       FD_ZERO(&rd);
  1766.       FD_SET(sockpair[0], &rd);
  1767.       e = select ( sockpair[0] + 1, &rd, NULL, NULL, &tv);
  1768.       } while ( e < 0 && errno == EINTR );
  1769.       
  1770.       if ( e > 0 )
  1771.       {
  1772.        e = internal_recv(sockpair[0], &buf, &bufsz, &type);
  1773.        if (e < 0 || ( type & INTERNAL_COMM_MSG_TYPE_CTRL ) )
  1774. {
  1775.          e = waitpid(pid,&status,WNOHANG);
  1776.          _plug_get_key_son = 0;
  1777.          close(sockpair[0]);
  1778.          sig_term(_exit);
  1779.  break;
  1780. }
  1781.        else internal_send(upstream, buf, type);
  1782.       }
  1783.      }
  1784.      }
  1785.    res = res->next;
  1786.    }
  1787.    internal_send(upstream, NULL, INTERNAL_COMM_MSG_TYPE_CTRL | INTERNAL_COMM_CTRL_FINISHED);
  1788.    exit(0);
  1789. }
  1791. /*
  1792.  * Don't always return the first open port, otherwise
  1793.  * we might get bitten by OSes doing active SYN flood
  1794.  * countermeasures. Also, avoid returning 80 and 21 as
  1795.  * open ports, as many transparent proxies are acting for these...
  1796.  */
  1797. ExtFunc unsigned int
  1798. plug_get_host_open_port(struct arglist * desc)
  1799. {
  1800.  struct kb_item ** kb = plug_get_kb(desc);
  1801.  char * t;
  1802.  int port = 0;
  1803.  struct kb_item * res, *k;
  1804.  int open21 = 0, open80 = 0;
  1805. #define MAX_CANDIDATES 16
  1806.  u_short candidates[MAX_CANDIDATES];
  1807.  int num_candidates = 0;
  1808.  
  1809.  k = res = kb_item_get_pattern(kb, "Ports/tcp/*");
  1810.  if ( res == NULL ) 
  1811.     return 0;
  1812.  else 
  1813.     {
  1814.      int ret;
  1815.      char * s;
  1816.  
  1817.      for(;;)
  1818.      {
  1819.       s = res->name + sizeof("Ports/tcp/") - 1;
  1820.       ret = atoi(s);
  1821.       if ( ret == 21 ) open21 = 1;
  1822.       else if ( ret == 80 ) open80 = 1;
  1823.       else  {
  1824.                 candidates[num_candidates++] = ret;
  1825.                 if ( num_candidates >= MAX_CANDIDATES ) break;
  1826.     }
  1827.       res = res->next;
  1828.       if ( res == NULL ) break;
  1829.      }
  1831.      kb_item_get_all_free(k);
  1832.      if ( num_candidates != 0 )
  1833.        return candidates[lrand48() % num_candidates];
  1834.      else  
  1835.           if (open21) return 21;
  1836.      else  
  1837.           if (open80) return 80;
  1838.      else  
  1839.           return 0;
  1840.     }
  1842.  /* Not reachable */
  1843.  return 0;
  1844. }
  1847.        
  1848.  
  1849. /*
  1850.  * Those brain damaged functions should probably be in another file
  1851.  * They are use to remember who speaks SSL or not
  1852.  */
  1853.    
  1854. ExtFunc
  1855. void plug_set_port_transport(args, port, tr)
  1856.      struct arglist * args;
  1857.      int port, tr;
  1858. {
  1859.   char s[256];
  1861.   snprintf(s, sizeof(s), "Transports/TCP/%d", port);
  1862.   plug_set_key(args, s, ARG_INT, (void*)tr);
  1863. }
  1865. ExtFunc
  1866. int plug_get_port_transport(args, port)
  1867.      struct arglist * args;
  1868.      int port;
  1869. {
  1870.   char s[256];
  1871.   int trp;
  1872.   
  1873.   snprintf(s, sizeof(s), "Transports/TCP/%d", port);
  1874.   trp = kb_item_get_int(plug_get_kb(args), s);
  1875.   if (trp >= 0)
  1876.     return trp;
  1877.   else 
  1878.     return NESSUS_ENCAPS_IP; /* Change this to 0 for ultra smart SSL negotiation, at the expense
  1879.                                 of possibly breaking stuff */
  1880. }
  1882. ExtFunc
  1883. const char* plug_get_port_transport_name(args, port)
  1884.      struct arglist * args;
  1885.      int port;
  1886. {
  1887.   return get_encaps_name(plug_get_port_transport(args, port));
  1888. }
  1890. #ifdef HAVE_SSL
  1891. static void
  1892. plug_set_ssl_item(args, item, itemfname)
  1893.  struct arglist * args;
  1894.  char * item;
  1895.  char * itemfname;
  1896. {
  1897.  char s[256];
  1898.  snprintf(s, sizeof(s), "SSL/%s", item);
  1899.  plug_set_key(args, s, ARG_STRING, itemfname);
  1900. }
  1902. ExtFunc void
  1903. plug_set_ssl_cert(args, cert)
  1904.  struct arglist * args;
  1905.  char * cert;
  1906. {
  1907.  plug_set_ssl_item(args, "cert", cert);
  1908. }
  1910. ExtFunc void 
  1911. plug_set_ssl_key(args, key)
  1912.  struct arglist * args;
  1913.  char * key;
  1914. {
  1915.  plug_set_ssl_item(args, "key", key);
  1916. }
  1917. ExtFunc void
  1918. plug_set_ssl_pem_password(args, key)
  1919.  struct arglist * args;
  1920.  char * key;
  1921. {
  1922.  plug_set_ssl_item(args, "password", key);
  1923. }
  1925. ExtFunc void
  1926. plug_set_ssl_CA_file(args, key)
  1927.  struct arglist * args;
  1928.  char * key;
  1929. {
  1930.  plug_set_ssl_item(args, "CA", key);
  1931. }
  1932. #else
  1933. ExtFunc  void
  1934. plug_set_ssl_cert(args, cert)
  1935.  struct arglist * args;
  1936.  char * cert;
  1937. {
  1938.  fprintf(stderr, "plug_set_ssl_cert(): not implementedn");
  1939. }
  1941. ExtFunc void
  1942. plug_set_ssl_key(args, key)
  1943.  struct arglist * args;
  1944.  char * key;
  1945. {
  1946.  fprintf(stderr, "plug_set_ssl_key(): not implementedn");
  1947. }
  1948. #endif /* HAVE_SSL */
  1951. ExtFunc char *
  1952. find_in_path(name, safe)
  1953.      char *name;
  1954.      int safe;
  1955. {
  1956.   char *buf = getenv("PATH"), *pbuf, *p1, *p2;
  1957.   static char cmd[MAXPATHLEN];
  1958.   int len = strlen(name);
  1959.   
  1960.   if (len >= MAXPATHLEN)
  1961.     return NULL;
  1963. #if 0
  1964.   /* Proposed by Devin Kowatch 
  1965.      If it's already an absolute path take it as is */
  1966.   if (name[0] == '/' && access(name, X_OK) == 0)
  1967.     return name; /* Invalid: we should remove everything after the last / */
  1968. #endif
  1970.   if (buf == NULL) /* Should we use a standard PATH here? */
  1971.     return NULL;
  1973.   pbuf = buf;
  1974.   while (*pbuf != '')
  1975.     {
  1976.       for (p1 = pbuf, p2 = cmd; *p1 != ':' && *p1 != ''; )
  1977. *p2 ++ = *p1 ++;
  1978.       *p2 = '';
  1979.       if (*p1 == ':')
  1980. p1 ++;
  1981.       pbuf = p1;
  1982.       if (p2 == cmd) /* :: found in $PATH */
  1983. strcpy(cmd, ".");
  1985.       if (cmd[0] != '/' && safe)
  1986. continue;
  1987.       if (p2 - cmd + 1 + len >= MAXPATHLEN)
  1988. /* path too long: cannot be reached */
  1989. continue;
  1991.       sprintf(p2, "/%s", name);
  1992.       if (access(cmd, X_OK) == 0)
  1993. {
  1994.   struct stat st;
  1995.   if (stat(cmd, &st) < 0)
  1996.     perror(cmd);
  1997.   else if (S_ISREG(st.st_mode))
  1998.     {
  1999.       *p2 = '';
  2000. #if 0
  2001.       fprintf(stderr, "find_in_path: %s found in %sn", name, cmd);
  2002. #endif
  2003.       return cmd;
  2004.     }
  2005. }
  2006. #if 0
  2007.   fprintf(stderr, "find_in_path: No %sn", cmd);
  2008. #endif
  2009.     }
  2010.   return NULL;
  2011. }
  2013. ExtFunc int 
  2014. is_shell_command_present(name)
  2015.  char * name;
  2016. {
  2017.   return find_in_path(name, 0) != NULL;
  2018. }
  2022. ExtFunc int shared_socket_register ( struct arglist * args, int fd, char * name )
  2023. {
  2024.  int soc; 
  2025.  int type;
  2026.  unsigned int opt_len = sizeof(type);
  2027.  int e;  
  2028.  soc = (int)arg_get_value(args, "SOCKET");
  2029.  if ( fd_is_stream(fd) )
  2030.   fd = nessus_get_socket_from_connection(fd);
  2033.  e = getsockopt(fd, SOL_SOCKET, SO_TYPE, &type, &opt_len);
  2034.  if ( e < 0 )
  2035.  {
  2036.   fprintf(stderr, "shared_socket_register(): Not a socket! - %sn", strerror(errno));
  2037.   return -1;
  2038.  }
  2040.  internal_send(soc, name, INTERNAL_COMM_MSG_SHARED_SOCKET|INTERNAL_COMM_SHARED_SOCKET_REGISTER);
  2041.  internal_send(soc, NULL, INTERNAL_COMM_MSG_SHARED_SOCKET|INTERNAL_COMM_SHARED_SOCKET_DORECVMSG);
  2042.  send_fd(soc, fd);
  2043.  return 0;
  2044. }
  2046. ExtFunc int shared_socket_acquire ( struct arglist * args, char * name )
  2047. {
  2048.  int soc; 
  2049.  char * buf = NULL;
  2050.  int bufsz = 0;
  2051.  int msg;
  2053.  soc = (int)arg_get_value(args, "SOCKET");
  2055.  /* Wait forever until SHARED_SOCKET_ACQUIRE is true */
  2056.  for ( ;; )
  2057.  {
  2058.  if ( internal_send(soc, name, INTERNAL_COMM_MSG_SHARED_SOCKET|INTERNAL_COMM_SHARED_SOCKET_ACQUIRE) < 0 ) break;
  2059.  if ( internal_recv(soc, &buf, &bufsz, &msg) < 0 ) break;
  2060.  if ( ( msg & INTERNAL_COMM_MSG_SHARED_SOCKET) == 0 )
  2061. {
  2062.  fprintf(stderr, "[%d] shared_socket_acquire(): unexpected message - %dn", getpid(), msg);
  2063.  return -1;
  2064. }
  2065.   if ( msg & INTERNAL_COMM_SHARED_SOCKET_ERROR )
  2066.  return -1;
  2067.   else if ( msg & INTERNAL_COMM_SHARED_SOCKET_BUSY )
  2068.  sleep(1);
  2069.   else if ( msg & INTERNAL_COMM_SHARED_SOCKET_DORECVMSG )
  2070.   {
  2071.    int fd = recv_fd(soc);
  2072.    return fd;
  2073.   }
  2074.  }
  2076.  /* Unreachable */
  2077.  return -1;
  2078. }
  2079.  
  2081. ExtFunc int shared_socket_release ( struct arglist * args, char * name )
  2082. {
  2083.  int soc; 
  2085.  soc = (int)arg_get_value(args, "SOCKET");
  2086.  return internal_send(soc, name, INTERNAL_COMM_MSG_SHARED_SOCKET|INTERNAL_COMM_SHARED_SOCKET_RELEASE);
  2087. }
  2089. ExtFunc int shared_socket_destroy ( struct arglist * args, char * name )
  2090. {
  2091.  int soc; 
  2093.  soc = (int)arg_get_value(args, "SOCKET");
  2094.  return internal_send(soc, name, INTERNAL_COMM_MSG_SHARED_SOCKET|INTERNAL_COMM_SHARED_SOCKET_DESTROY);
  2095. }