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

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

Telnet服务器

开发平台：

Unix_Linux

network.c：源码内容
  1. /* Nessuslib -- the Nessus Library
  2.  * Copyright (C) 1998 - 2002 Renaud Deraison
  3.  * SSL Support Copyright (C) 2001 Michel Arboi
  4.  *
  5.  * This library is free software; you can redistribute it and/or
  6.  * modify it under the terms of the GNU Library General Public
  7.  * License as published by the Free Software Foundation; either
  8.  * version 2 of the License, or (at your option) any later version.
  9.  *
  10.  * This library is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.  * Library General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU Library General Public
  16.  * License along with this library; if not, write to the Free
  17.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  *
  19.  * Network Functions
  20.  */ 
  22. #define EXPORTING
  23. #include <includes.h>
  24. #include <stdarg.h>
  25. #include "libnessus.h"
  26. #include "network.h"
  27. #include "resolve.h"
  28. #include "ids_send.h"
  30. #include <setjmp.h>
  32. #ifdef HAVE_SSL
  33. #include <openssl/bio.h>
  34. #include <openssl/err.h>
  35. #include <openssl/rand.h>
  36. #endif
  38. #define TIMEOUT 20
  40. #ifndef INADDR_NONE
  41. #define INADDR_NONE 0xffffffff
  42. #endif
  44. extern int plug_get_port_transport(struct arglist*, int);
  45. extern void plug_set_port_transport(struct arglist*, int, int);
  48. /*----------------------------------------------------------------*
  49.  * Low-level connection management                                *
  50.  *----------------------------------------------------------------*/
  51.  
  52. /* Nessus "FILE" structure */
  53. typedef struct {
  54.  int fd; /* socket number, or whatever */
  55.  int transport; /* "transport" layer code when stream is encapsultated. 
  56.  * Negative transport signals a free descriptor */
  57.  int timeout;   /* timeout, in seconds
  58.    * special values: -2 for default */
  59.  int options; /* Misc options - see libnessus.h */
  60.   
  61.  int port;  
  62. #ifdef HAVE_SSL
  63.   SSL_CTX*  ssl_ctx; /* SSL context  */
  64.   SSL_METHOD*  ssl_mt; /* SSL method   */
  65.   SSL*  ssl; /* SSL handler  */
  66.   int last_ssl_err; /* Last SSL error code */
  67. #endif
  68.  pid_t pid; /* Owner - for debugging only */
  70.   char* buf; /* NULL if unbuffered */
  71.   int bufsz, bufcnt, bufptr;
  72.   int  last_err;
  73. } nessus_connection;
  75. /* 
  76.  * The role of this offset is:
  77.  * 1. To detect bugs when the program tries to write to a bad fd
  78.  * 2. See if a fd is a real socket or a "nessus descriptor". This is a
  79.  * quick & dirty hack and should be changed!!!
  80.  */
  81. #define NESSUS_FD_MAX 1024
  82. #define NESSUS_FD_OFF 1000000
  84. static nessus_connection connections[NESSUS_FD_MAX];
  86. /*
  87.  * Quick & dirty patch to run Nessus from behind a picky firewall (e.g.
  88.  * FW/1 and his 'Rule 0'): Nessus will never open more than 1 connection at
  89.  * a time.
  90.  * Define NESSUS_CNX_LOCK, recompile and install nessus-library, and restart nessusd
  91.  *
  92.  * WARNING: waiting on the lock file may be long, so increase the default
  93.  * script timeout or some scripts may be killed.
  94.  */
  95. #undef NESSUS_CNX_LOCK
  96. /*#define NESSUS_CNX_LOCK "/tmp/NessusCnx"*/
  98. #ifdef NESSUS_CNX_LOCK
  99. static int lock_cnt = 0;
  100. static int lock_fd = -1;
  101. #endif
  103. /*
  104.  * NESSUS_STREAM(x) is TRUE if <x> is a Nessus-ified fd
  105.  */
  106. #define NESSUS_STREAM(x) (((x - NESSUS_FD_OFF) < NESSUS_FD_MAX) && ((x - NESSUS_FD_OFF) >=0))
  109. static void
  110. renice_myself()
  111. {
  112.  static pid_t pid = 0;
  113.  pid_t cpid = getpid();
  114.  
  115.  if( pid != cpid )
  116.  {
  117.   if(nice(0) >= 10)return;
  118.   pid = cpid;
  119.   nice(1);
  120.  }
  121. }
  122. /*
  123.  * Same as perror(), but prefixes the data by our pid
  124.  */
  125. static int 
  126. nessus_perror(error)
  127.  const char* error;
  128. {
  129.   fprintf(stderr, "[%d] %s : %sn", getpid(), error, strerror(errno));
  130.   return 0;
  131. }
  133. /*
  134.  * Returns the amount of data waiting to be read in the socket
  135.  * or -1 in case of an error (errno will be set)
  136.  */
  137. #if 0
  138. static int data_left(soc)
  139.  int soc;
  140. {
  141.  int len = 0;
  142.  int ret = ioctl(soc, FIONREAD, &len);
  143.  if (ret >= 0) {
  144.   if(len <= 0)
  145.    return 0;
  146.   else 
  147.    return len;
  148.  }
  149.  else {
  150.   nessus_perror("ioctl(FIONREAD)");
  151.   return -1;
  152.  }
  153. } /* data_left */
  154. #endif
  156. int
  157. stream_get_err(fd)
  158.  int fd;
  159. {
  160.  nessus_connection *p;
  161.  
  162.  if(!NESSUS_STREAM(fd))
  163.     {
  164.      errno = EINVAL;
  165.      return -1;
  166.     }
  167.     
  168.     
  169.  p = &(connections[fd - NESSUS_FD_OFF]);
  170.  return p->last_err;
  171. }
  173. /*
  174.  * Returns a free file descriptor
  175.  */
  176. static int
  177. get_connection_fd()
  178. {
  179.  int i;
  180.  
  181.  for ( i = 0; i < NESSUS_FD_MAX ; i++)
  182.  {
  183.   if(connections[i].transport <= 0) /* Not used */
  184.   {
  185.    bzero(&(connections[i]),  sizeof(connections[i]));
  186.    connections[i].pid = getpid();
  187.    return i + NESSUS_FD_OFF;
  188.   }
  189.  }
  190.  fprintf(stderr, "[%d] %s:%d : Out of Nessus file descriptorsn", 
  191.  getpid(), __FILE__, __LINE__);
  192.  errno = EMFILE;
  193.  return -1;
  194. }
  198. static int
  199. release_connection_fd(fd)
  200.  int fd;
  201. {
  202.  nessus_connection *p;
  203.  
  204.  if(!NESSUS_STREAM(fd))
  205.     {
  206.      errno = EINVAL;
  207.      return -1;
  208.     }
  209.     
  210.     
  211.  p = &(connections[fd - NESSUS_FD_OFF]);
  213.  efree(&p->buf);
  215. #ifdef HAVE_SSL
  216.  if (p->ssl != NULL)
  217.   SSL_free(p->ssl);
  218.  if (p->ssl_ctx != NULL)
  219.   SSL_CTX_free(p->ssl_ctx);
  220. #endif
  222. /* 
  223.  * So far, fd is always a socket. If this is changed in the future, this
  224.  * code shall be fixed
  225.  */
  226. if (p->fd >= 0)
  227.  {
  228.   if (shutdown(p->fd, 2) < 0)
  229.     {
  230. #if DEBUG_SSL > 1
  231.     /*
  232.      * It's not uncommon to see that one fail, since a lot of
  233.      * services close the connection before we ask them to
  234.      * (ie: http), so we don't show this error by default
  235.      */
  236.     nessus_perror("release_connection_fd: shutdown()");
  237. #endif    
  238.     }
  239.   if (socket_close(p->fd)  < 0)
  240.     nessus_perror("release_connection_fd: close()");
  241.  }
  242.  bzero(p, sizeof(*p));
  243.  p->transport = -1; 
  244.  return 0;
  245. }
  247. /* ******** Compatibility function ******** */
  249. ExtFunc int
  250. nessus_register_connection(s, ssl)
  251.      int s;
  252. #ifdef HAVE_SSL
  253.      SSL *ssl;
  254. #else
  255.      void *ssl;
  256. #endif
  257. {
  258.   int fd;
  259.   nessus_connection *p;
  261.   if((fd = get_connection_fd()) < 0)
  262.     return -1;
  263.   p = connections + (fd - NESSUS_FD_OFF);
  264. #ifdef HAVE_SSL 
  265.   p->ssl_ctx = NULL;
  266.   p->ssl_mt = NULL; /* shall be freed elsewhere */
  267.   p->ssl = ssl; /* will be freed on close */
  268. #endif  
  269.   p->timeout = TIMEOUT; /* default value */
  270.   p->port = 0; /* just used for debug */
  271.   p->fd = s;
  272.   p->transport = (ssl != NULL) ? NESSUS_ENCAPS_SSLv23 : NESSUS_ENCAPS_IP;
  273.   p->last_err  = 0;
  274.   return fd;
  275. }
  277. ExtFunc int
  278. nessus_deregister_connection(fd)
  279.  int fd;
  280. {
  281.  nessus_connection * p;
  282.  if(!NESSUS_STREAM(fd))
  283.  {
  284.   errno = EINVAL;
  285.   return -1;
  286.  }
  287.  
  288.  p = connections +  (fd - NESSUS_FD_OFF);
  289.  bzero(p, sizeof(*p));
  290.  p->transport = -1; 
  291.  return 0;
  292. }
  294. /*----------------------------------------------------------------*
  295.  * High-level connection management                               *
  296.  *----------------------------------------------------------------*/
  298. static int __port_closed;
  300. static int unblock_socket(int soc)
  301. {
  302.   int flags =  fcntl(soc, F_GETFL, 0);
  303.   if (flags < 0)
  304. {
  305.       nessus_perror("fcntl(F_GETFL)");
  306.       return -1;
  307.     }
  308.   if (fcntl(soc, F_SETFL, O_NONBLOCK | flags) < 0)
  309.     {
  310.       nessus_perror("fcntl(F_SETFL,O_NONBLOCK)");
  311.       return -1;
  312.     }
  313.   return 0;
  314. }
  316. static int block_socket(int soc)
  317. {
  318.   int flags =  fcntl(soc, F_GETFL, 0);
  319.   if (flags < 0)
  320.     {
  321.       nessus_perror("fcntl(F_GETFL)");
  322.       return -1;
  323.     }
  324.   if (fcntl(soc, F_SETFL, (~O_NONBLOCK) & flags) < 0)
  325.     {
  326.       nessus_perror("fcntl(F_SETFL,~O_NONBLOCK)");
  327.       return -1;
  328.     }
  329.   return 0;
  330. }
  332. /*
  333.  * Initialize the SSL library (error strings and algorithms) and try
  334.  * to set the pseudo random generator to something less silly than the
  335.  * default value: 1 according to SVID 3, BSD 4.3, ISO 9899 :-(
  336.  */
  338. #ifdef HAVE_SSL
  339. /* Adapted from stunnel source code */
  340. ExtFunc
  341. void sslerror2(txt, err)
  342.      char *txt;
  343.      int err;
  344. {
  345.   char string[120];
  347.   ERR_error_string(err, string);
  348.   fprintf(stderr, "[%d] %s: %sn", getpid(), txt, string);
  349. }
  351. void
  352. sslerror(txt)
  353.      char *txt;
  354. {
  355.   sslerror2(txt, ERR_get_error());
  356. }
  357. #endif
  359. ExtFunc int
  360. nessus_SSL_init(path)
  361.      char *path; /* entropy pool file name */
  362. {
  363. #ifdef HAVE_SSL
  364.   SSL_library_init();
  365.   SSL_load_error_strings();
  367. #ifdef HAVE_RAND_STATUS
  368.   if (RAND_status() == 1)
  369.     {
  370.     /* The random generator is happy with its current entropy pool */
  371.     return 0;
  372.    }
  373. #endif
  376.   /*
  377.    * Init the random generator
  378.    *
  379.    * OpenSSL provides nice functions for this job.
  380.    * OpenSSL also ensures that each thread uses a different seed.
  381.    * So this function should be called *before* forking.
  382.    * Cf. http://www.openssl.org/docs/crypto/RAND_add.html#
  383.    *
  384.    * On systems that have /dev/urandom, SSL uses it transparently to seed 
  385.    * its PRNG
  386.    */
  388.  
  389. #if 0
  390.   RAND_screen(); /* Only available under MSWin */
  391. #endif
  393. #ifdef EGD_PATH
  394.   /*
  395.    * We have the entropy gathering daemon.
  396.    * However, OpenSSL automatically query it if it is not in some odd place
  397.    */
  398.   if(RAND_egd(EGD_PATH) > 0)
  399.   return 0;
  400. #endif
  402.    if (path != NULL)
  403.     {
  404.     (void) RAND_load_file(path, -1);
  405.     RAND_write_file(path);
  406.     }
  407.    else
  408.    {
  409.     /*
  410.      * Try with the default path
  411.      */
  412.     char path[1024];
  413.     if(RAND_file_name(path, sizeof(path) - 1) == 0)
  414.     return -1;
  415.     path[sizeof(path) - 1] = '';
  416.     if(RAND_load_file(path, -1) < 0)
  417.     return -1;
  418.     RAND_write_file(path);
  419.     return 0;
  420.    } 
  421. #endif
  422.    return -1;
  423. }
  425. #ifdef HAVE_SSL
  426. # if 0
  427. ExtFunc void
  428. nessus_print_SSL_certificate(cert)
  429.      X509* cert;    
  430. {
  431.  BIO * b;
  432.  BUF_MEM * bptr;
  433.  char * ret = NULL;
  434.  int i;
  436.  if(cert == NULL)
  437.    return;
  439.  b = BIO_new(BIO_s_mem());
  440.  if(X509_print(b, cert) > 0)
  441.    {
  442.      BIO_get_mem_ptr(b, &bptr);
  443.      printf("* Peer certificate *n");
  444.      for(i = 0; i < bptr->length; i ++)
  445.        putchar(bptr->data[i]);
  446.      printf("n********************n");
  447.    }
  448.  BIO_free(b);
  449. }
  451. ExtFunc void
  452. nessus_print_peer_SSL_certificate(ssl)
  453.      SSL* ssl;
  454. {
  455.   X509 * cert = SSL_get_peer_certificate(ssl);
  456.   nessus_print_SSL_certificate(cert);
  457. }
  458. # endif
  459. #endif
  462. static int
  463. nessus_SSL_password_cb(buf, size, rwflag, userdata)
  464.      char *buf;
  465.      int size;
  466.      int rwflag;
  467.      void *userdata;
  468. {
  469.   if (userdata != NULL)
  470.     {
  471.       buf[size - 1] = '';
  472.       strncpy(buf, userdata, size - 1);
  473.       return strlen(buf);
  474.     }
  475.   else
  476.     {
  477. #if DEBUG_SSL > 1
  478.       fprintf(stderr, "nessus_SSL_password_cb: returning empty passwordn");
  479. #endif
  480.       *buf = '';
  481.       return 0;
  482.     }
  483. }
  485. ExtFunc int
  486. nessus_get_socket_from_connection(fd)
  487.      int fd;
  488. {
  489.   nessus_connection *fp;
  491.   if (!NESSUS_STREAM(fd))
  492.     {
  493.       fprintf(stderr,
  494.       "[%d] nessus_get_socket_from_connection: bad fd <%d>n", getpid(), fd);
  495.       fflush(stderr);
  496.       return fd;
  497.     }
  498.   fp = connections + (fd - NESSUS_FD_OFF);
  499.   if(fp->transport <= 0)
  500.     {
  501.       fprintf(stderr, "nessus_get_socket_from_connection: fd <%d> is closedn", fd);
  502.       return -1;
  503.     }
  504.   return fp->fd;
  505. }
  508. #ifdef HAVE_SSL
  509. ExtFunc void
  510. nessus_install_passwd_cb(ssl_ctx, pass)
  511.      SSL_CTX *ssl_ctx;
  512.      char *pass;
  513. {
  514.   SSL_CTX_set_default_passwd_cb(ssl_ctx, nessus_SSL_password_cb);
  515.   SSL_CTX_set_default_passwd_cb_userdata(ssl_ctx, pass);
  516. }
  518. static int
  519. open_SSL_connection(fp, timeout, cert, key, passwd, cert_names)
  520.      nessus_connection *fp;
  521.      int timeout;
  522.      char *cert, *key, *passwd; 
  523.      STACK_OF(X509_NAME) *cert_names;
  524. {
  525.   int ret, err, d;
  526.   time_t tictac;
  527.   fd_set fdw, fdr;
  528.   struct timeval to;
  531.   nessus_SSL_init(NULL);
  533.   switch (fp->transport)
  534.     {
  535.     case NESSUS_ENCAPS_SSLv2:
  536.       fp->ssl_mt = SSLv2_client_method();
  537.       break;
  538.     case NESSUS_ENCAPS_SSLv3:
  539.       fp->ssl_mt = SSLv3_client_method();
  540.       break;
  541.     case NESSUS_ENCAPS_TLSv1:
  542.       fp->ssl_mt = TLSv1_client_method();
  543.       break;
  544.     case NESSUS_ENCAPS_SSLv23: /* Compatibility mode */
  545.       fp->ssl_mt = SSLv23_client_method();
  546.       break;
  547.       
  548.     default:
  549. #if DEBUG_SSL > 0
  550.       fprintf(stderr, "*Bug* at %s:%d. Unknown transport %dn",
  551.       __FILE__, __LINE__, fp->transport);
  552. #endif
  553.       fp->ssl_mt = SSLv23_client_method();
  554.       break;
  555.     }
  557.   if((fp->ssl_ctx = SSL_CTX_new(fp->ssl_mt)) == NULL)
  558.     return -1;
  560.   if (SSL_CTX_set_options(fp->ssl_ctx, SSL_OP_ALL) < 0)
  561.     sslerror("SSL_CTX_set_options(SSL_OP_ALL)");
  563.   if ((fp->ssl = SSL_new(fp->ssl_ctx)) == NULL)
  564.     return -1;
  566.   /* Client certificates should not be used if we are in SSLv2 */
  567.   if (fp->transport != NESSUS_ENCAPS_SSLv2) {
  568.   SSL_CTX_set_default_passwd_cb(fp->ssl_ctx, nessus_SSL_password_cb);
  569.   SSL_CTX_set_default_passwd_cb_userdata(fp->ssl_ctx, passwd);
  571.   if (cert != NULL)
  572.     SSL_use_certificate_file(fp->ssl, cert, SSL_FILETYPE_PEM);
  573.   if (key != NULL)
  574. #if 1
  575.     SSL_use_PrivateKey_file(fp->ssl, key, SSL_FILETYPE_PEM);
  576. #else
  577.     SSL_use_RSAPrivateKey_file(fp->ssl, key, SSL_FILETYPE_PEM);
  578. #endif
  580.     if (cert_names != NULL)
  581.       SSL_CTX_set_client_CA_list(fp->ssl_ctx, cert_names);
  582.     }
  584.   unblock_socket(fp->fd);
  586.   if(! (ret = SSL_set_fd(fp->ssl, fp->fd)))
  587.     {
  588. #if DEBUG_SSL > 0
  589.       sslerror("SSL_set_fd");
  590. #endif    
  591.       return -1;
  592.     }
  593.     
  594.   tictac = time(NULL);
  595.   for (;;)
  596.     {
  597.   ret = SSL_connect(fp->ssl);
  598. #if 0
  599.       block_socket(fp->fd);
  600. #endif
  601.       if (ret > 0)
  602. return ret;
  604.       fp->last_ssl_err = err = SSL_get_error(fp->ssl, ret);
  605.       FD_ZERO(&fdr); FD_ZERO(&fdw);
  606.       switch (err)
  607.     {
  608. case SSL_ERROR_WANT_READ:
  609. #if DEBUG_SSL > 2
  610.   fprintf(stderr, "SSL_Connect[%d]: SSL_ERROR_WANT_READn", getpid());
  611. #endif
  612.   FD_SET(fp->fd, &fdr);
  613.   break;
  614. case SSL_ERROR_WANT_WRITE:
  615. #if DEBUG_SSL > 2
  616.   fprintf(stderr, "SSL_Connect[%d]: SSL_ERROR_WANT_WRITEn", getpid());
  617. #endif
  618.   FD_SET(fp->fd, &fdw);
  619.   break;
  620. default:
  621. #ifdef DEBUG_SSL 
  622.   sslerror2("SSL_connect", err);
  623. #endif
  624.          return -1;
  625.     }
  626.      
  627.       do
  628. {
  629.   d = tictac + timeout - time(NULL);
  630.   if (d <= 0)
  631.     {
  632.     fp->last_err = ETIMEDOUT;
  633.     return -1;
  634.             }
  635.   to.tv_sec = d;
  636.   to.tv_usec = 0;
  637.   errno = 0;
  638.   if ((ret = select(fp->fd + 1, &fdr, &fdw, NULL, &to)) <= 0)
  639.     {
  640. #if DEBUG_SSL > 1
  641.       nessus_perror("select");
  642. #endif
  643.     }
  644. }
  645.       while (ret < 0 && errno == EINTR);
  646.       if (ret <= 0)
  647. {
  648. fp->last_err = ETIMEDOUT;
  649. return -1;
  650.         }
  651.     }
  652.   /*NOTREACHED*/
  653. }
  654. #endif
  657. static void
  658. set_ids_evasion_mode(args, fp)
  659.      struct arglist *args;
  660.      nessus_connection *fp;
  661. {
  662.  struct kb_item ** kb = plug_get_kb(args);
  663.  char *ids_evasion_split = kb_item_get_str(kb, "NIDS/TCP/split");
  664.  char  *ids_evasion_inject = kb_item_get_str(kb, "NIDS/TCP/inject");
  665.  char  *ids_evasion_short_ttl = kb_item_get_str(kb,"NIDS/TCP/short_ttl");
  666.  char *ids_evasion_fake_rst = kb_item_get_str(kb, "NIDS/TCP/fake_rst");
  667.  int option = 0;
  668.  
  669.  
  670.  /*
  671.   * These first three options are mutually exclusive
  672.   */
  673.  if(ids_evasion_split != NULL && strcmp(ids_evasion_split, "yes") == 0)
  674.   option = NESSUS_CNX_IDS_EVASION_SPLIT;
  676.  if(ids_evasion_inject != NULL && strcmp(ids_evasion_inject, "yes") == 0)
  677.   option = NESSUS_CNX_IDS_EVASION_INJECT;
  678.  
  679.  if(ids_evasion_short_ttl != NULL && strcmp(ids_evasion_short_ttl, "yes") == 0)
  680.   option = NESSUS_CNX_IDS_EVASION_SHORT_TTL;
  683.  /*
  684.   * This is not exclusive with the above
  685.   */
  686.  if(ids_evasion_fake_rst != NULL && strcmp(ids_evasion_fake_rst, "yes") == 0)
  687.   option |= NESSUS_CNX_IDS_EVASION_FAKE_RST;
  689.  if(option)
  690.    {
  691. #ifdef SO_SNDLOWAT
  692.      int n = 1;
  693.      (void) setsockopt(fp->fd, SOL_SOCKET, SO_SNDLOWAT, (void*)&n, sizeof(n));
  694. #endif
  695.      fp->options |= option;
  696.    }
  697. }
  699. ExtFunc int
  700. open_stream_connection(args, port, transport, timeout)
  701.  struct arglist * args;
  702.  unsigned int port;
  703.  int transport, timeout;
  704. {
  705.  int fd;
  706.  nessus_connection * fp;
  707. #ifdef HAVE_SSL
  708.  char * cert   = NULL;
  709.  char * key    = NULL;
  710.  char * passwd = NULL;
  711.  char * cafile = NULL;
  712.  STACK_OF(X509_NAME) *cert_names = NULL;
  713. #endif
  715. #if DEBUG_SSL > 2
  716.  fprintf(stderr, "[%d] open_stream_connection: TCP:%d transport:%d timeout:%dn",
  717.        getpid(), port, transport, timeout);
  718. #endif
  720.  if(timeout == -2)
  721.   timeout = TIMEOUT;
  722.   
  723.  switch(transport)
  724.  {
  725.   case NESSUS_ENCAPS_IP:
  726. #ifdef HAVE_SSL
  727.   case NESSUS_ENCAPS_SSLv2:
  728.   case NESSUS_ENCAPS_SSLv23:
  729.   case NESSUS_ENCAPS_SSLv3:
  730.   case NESSUS_ENCAPS_TLSv1:
  731. #endif 
  732.    break;
  733.   default:
  734.    fprintf(stderr, "open_stream_connection(): unsupported transport layer %dn",
  735.     transport);
  736.    errno = EINVAL;
  737.    return -1;
  738.  }
  739.  
  740.  if((fd = get_connection_fd()) < 0)
  741.   return -1;
  742.  
  743.  fp = &(connections[fd - NESSUS_FD_OFF]);
  744.  
  745.  
  746.  fp->transport = transport;
  747.  fp->timeout   = timeout;
  748.  fp->port      = port;
  749.  fp->last_err  = 0;
  750.  set_ids_evasion_mode(args, fp);
  752.  if(fp->options & NESSUS_CNX_IDS_EVASION_FAKE_RST)
  753.    fp->fd = ids_open_sock_tcp(args, port, fp->options, timeout);
  754.  else
  755.    fp->fd = open_sock_tcp(args, port, timeout);
  757.   if(fp->fd < 0)
  758.   goto failed;
  760.  switch(transport)
  761.  {
  762.   case NESSUS_ENCAPS_IP:
  763.     break;
  764. #ifdef HAVE_SSL
  765.   case NESSUS_ENCAPS_SSLv23:
  766.   case NESSUS_ENCAPS_SSLv3:
  767.   case NESSUS_ENCAPS_TLSv1:
  768.     renice_myself();
  769.     cert   = kb_item_get_str(plug_get_kb(args), "SSL/cert");
  770.     key    = kb_item_get_str(plug_get_kb(args), "SSL/key");
  771.     passwd = kb_item_get_str(plug_get_kb(args), "SSL/password");
  773.     cafile = kb_item_get_str(plug_get_kb(args), "SSL/CA");
  775.     if ((cafile != NULL) && cafile[0] != '')
  776.       {
  777. cert_names = SSL_load_client_CA_file(cafile);
  778. if (cert_names == NULL)
  779.   {
  780.     char msg[512];
  781.     snprintf(msg, sizeof(msg), "SSL_load_client_CA_file(%s)", cafile);
  782.     sslerror(msg);
  783.   }
  784.      }
  785.    
  786.   case NESSUS_ENCAPS_SSLv2:
  787.     /* We do not need a client certificate in this case */
  789.     if (open_SSL_connection(fp, timeout, cert, key, passwd, cert_names) <= 0)
  790.     goto failed;
  791.   break;
  792. #endif
  793.  }
  794.  
  795.  return fd;
  797. failed:
  798.  release_connection_fd(fd);
  799.  return -1;
  800. }
  803. ExtFunc int
  804. open_stream_connection_unknown_encaps5(args, port, timeout, p, delta_t)
  805.  struct arglist * args;
  806.  unsigned int  port;
  807.  int timeout, * p;
  808.  int *delta_t; /* time, in micro-seconds */
  809. {
  810.  int fd;
  811.  int i;
  812.   struct timeval tv1, tv2;
  813.  static int encaps[] = {
  814. #ifdef HAVE_SSL
  815.    NESSUS_ENCAPS_SSLv2,
  816.    NESSUS_ENCAPS_TLSv1,
  817.    NESSUS_ENCAPS_SSLv3,
  818. #endif
  819.     NESSUS_ENCAPS_IP
  820.   };
  821.  
  822. #if DEBUG_SSL > 2
  823.  fprintf(stderr, "[%d] open_stream_connection_unknown_encaps: TCP:%d; %dn",
  824.  getpid(), port,timeout);
  825. #endif
  827.  for (i = 0; i < sizeof(encaps) / sizeof(*encaps); i ++)
  828.     {
  829.       if (delta_t != NULL) (void) gettimeofday(&tv1, NULL);
  830.    if ((fd = open_stream_connection(args, port, encaps[i], timeout)) >= 0)
  831.      {
  832.        *p = encaps[i];
  833. #if DEBUG_SSL > 2
  834.        fprintf(stderr, "[%d] open_stream_connection_unknown_encaps: TCP:%d -> transport=%dn", getpid(), port, *p);
  835. #endif
  836.   if (delta_t != NULL)
  837.     {
  838.       (void) gettimeofday(&tv2, NULL);
  839.       *delta_t = (tv2.tv_sec - tv1.tv_sec) * 1000000 + (tv2.tv_usec - tv1.tv_usec);
  840.     }
  841.        return fd;
  842.      }
  843.    else if (__port_closed)
  844.      {
  845. #if DEBUG_SSL > 2
  846.        fprintf(stderr, "[%d] open_stream_connection_unknown_encaps: TCP:%d -> closedn", getpid(), port);
  847. #endif
  848.        return -1;
  849.      }
  850.     }
  851.   return -1;
  852.  }
  853.  
  854. ExtFunc int
  855. open_stream_connection_unknown_encaps(args, port, timeout, p)
  856.  struct arglist * args;
  857.  unsigned int  port;
  858.  int timeout, * p;
  859. {
  860.   return open_stream_connection_unknown_encaps5(args, port, timeout, p, NULL);
  861. }
  864. ExtFunc int
  865. open_stream_auto_encaps(args, port, timeout)
  866.  struct arglist * args;
  867.  unsigned int     port;
  868.  int              timeout;
  869. {
  870.  int trp = plug_get_port_transport(args, port);
  871.  int fd;
  872.  
  873.  if(trp == 0)
  874.  {
  875.   if ((fd = open_stream_connection_unknown_encaps(args, port, timeout, &trp)) < 0)
  876.    return -1;
  877.   plug_set_port_transport(args, port, trp);
  878.   return fd;
  879.  }
  880.  else
  881.  {
  882.   fd = open_stream_connection(args, port, trp, timeout);
  883.   return fd;
  884.  }
  885.  /*NOTREACHED*/
  886. }
  889. #ifdef HAVE_SSL
  890. ExtFunc SSL*
  891. stream_get_ssl(fd)
  892.      int fd;
  893. {
  894.  nessus_connection * fp;
  895.  if(!NESSUS_STREAM(fd))
  896.     {
  897.      errno = EINVAL;
  898.      return NULL;
  899.     }
  900.   fp = &(connections[fd - NESSUS_FD_OFF]);
  901.   if (fp->transport <= 0)
  902.     return NULL;
  903.   else
  904.     return fp->ssl;
  905. }
  907. #endif
  909. ExtFunc int
  910. stream_set_timeout(fd, timeout)
  911.  int fd;
  912.  int timeout;
  913. {
  914.  int old;
  915.  nessus_connection * fp;
  916.  if(!NESSUS_STREAM(fd))
  917.     {
  918.      errno = EINVAL;
  919.      return 0;
  920.     }
  921.   fp = &(connections[fd - NESSUS_FD_OFF]);
  922.   old = fp->timeout;
  923.   fp->timeout = timeout;
  924.   return old;
  925. }
  927. ExtFunc int
  928. stream_set_options(fd, reset_opt, set_opt)
  929.      int fd, reset_opt, set_opt;
  930. {
  931.  nessus_connection * fp;
  932.  if(!NESSUS_STREAM(fd))
  933.     {
  934.      errno = EINVAL;
  935.      return -1;
  936.     }
  937.   fp = &(connections[fd - NESSUS_FD_OFF]);
  938.   fp->options &= ~reset_opt;
  939.   fp->options |= set_opt;
  940.   return 0;
  941. }
  944. static int 
  945. read_stream_connection_unbuffered(fd, buf0, min_len, max_len)
  946.  int fd;
  947.  void* buf0;
  948.  int min_len, max_len;
  949. {
  950.   int ret, realfd, trp, t, err;
  951.   int total = 0, flag = 0, timeout = TIMEOUT, waitall = 0;
  952.   unsigned char * buf = (unsigned char*)buf0;
  953.   nessus_connection *fp = NULL;
  954.   fd_set fdr, fdw;
  955.   struct timeval tv;
  956.   time_t now, then;
  958.   int   select_status;
  959.  
  960. #if 0
  961.   fprintf(stderr, "read_stream_connection(%d, 0x%x, %d, %d)n",
  962.   fd, buf, min_len, max_len);
  963. #endif
  965.   if (NESSUS_STREAM(fd))
  966.     {
  967.       fp = &(connections[fd - NESSUS_FD_OFF]);
  968.       trp = fp->transport;
  969.       realfd = fp->fd;
  970.       fp->last_err = 0;
  971.       if (fp->timeout != -2)
  972. timeout = fp->timeout;
  973.     }
  974.   else
  975.     {
  976. #if 0
  977.       fprintf(stderr, "read_stream_connection[%d] : supposedly bad fd %dn",
  978.       getpid(), fd);
  979. #endif
  980.       trp = NESSUS_ENCAPS_IP;
  981.       if(fd < 0 || fd > 1024)
  982.        {
  983. errno = EBADF;
  984. return -1;
  985. }
  986.       realfd = fd;
  987.     }
  989. #ifndef INCR_TIMEOUT
  990. # define INCR_TIMEOUT 1
  991. #endif
  993. #ifdef MSG_WAITALL
  994.   if (min_len == max_len || timeout <= 0)
  995.     waitall = MSG_WAITALL;
  996. #endif
  998.   if(trp == NESSUS_ENCAPS_IP)
  999.     {
  1000.       for (t = 0; total < max_len && (timeout <= 0 || t < timeout); )
  1001. {
  1002.   tv.tv_sec = INCR_TIMEOUT; /* Not timeout! */
  1003.   tv.tv_usec = 0;
  1004.   FD_ZERO(&fdr);
  1005.   FD_SET(realfd, &fdr);
  1006.   if(select(realfd + 1, &fdr, NULL, NULL, timeout > 0 ? &tv : NULL) <= 0)
  1007.     {
  1008.       t += INCR_TIMEOUT;
  1009.       /* Try to be smart */
  1010.       if (total > 0 && flag) 
  1011. return total;
  1012.       else if (total >= min_len)
  1013. flag ++;
  1014.     }
  1015.   else
  1016.     {
  1017.       errno = 0;
  1018.       ret = recv(realfd, buf + total, max_len - total, waitall);
  1019.       if (ret < 0)
  1020. if (errno != EINTR)
  1021.                   {
  1022.   fp->last_err = errno;
  1023.   return total;
  1024.                   }
  1025. else
  1026.   ret = 0;
  1027.       else if (ret == 0) /* EOF */
  1028.                 {
  1029.                 fp->last_err = EPIPE;
  1030. return total;
  1031.                 }
  1032.       /*ret > 0*/
  1033.       total += ret; 
  1034.       if (min_len > 0 && total >= min_len)
  1035. return total;
  1036.       flag = 0;
  1037.     }
  1038. }
  1039.       if ( t >= timeout ) fp->last_err = ETIMEDOUT;
  1040.       return total;
  1041.     }
  1043.   switch(trp)
  1044.     {
  1045.       /* NESSUS_ENCAPS_IP was treated before with the non-Nessus fd */
  1046. #ifdef HAVE_SSL
  1047.     case NESSUS_ENCAPS_SSLv2:
  1048.     case NESSUS_ENCAPS_SSLv23:
  1049.     case NESSUS_ENCAPS_SSLv3:
  1050.     case NESSUS_ENCAPS_TLSv1:
  1051. # if DEBUG_SSL > 0
  1052.       if (getpid() != fp->pid)
  1053. {
  1054.   fprintf(stderr, "PID %d tries to use a SSL connection established by PID %dn", getpid(), fp->pid);
  1055.   errno = EINVAL;
  1056.   return -1;
  1057. }
  1058. # endif
  1060.       FD_ZERO(&fdr); FD_ZERO(&fdw);
  1061.       FD_SET(realfd, &fdr); FD_SET(realfd, &fdw); 
  1062.       now = then = time(NULL);
  1063.       for (t = 0; timeout <= 0 || t < timeout; t = now - then )
  1064. {
  1065.           now = time(NULL);
  1066.   tv.tv_sec = INCR_TIMEOUT; tv.tv_usec = 0;
  1067.   select_status = select ( realfd + 1, &fdr, &fdw, NULL, &tv );
  1068.           if ( select_status == 0 )
  1069.           {
  1070.           FD_ZERO(&fdr); FD_ZERO(&fdw);
  1071.           FD_SET(realfd, &fdr); FD_SET(realfd, &fdw); 
  1072.           }
  1073.   else
  1074.   if ( select_status > 0 )
  1075.     {
  1076.   ret = SSL_read(fp->ssl, buf + total, max_len - total);
  1077.   if (ret > 0)
  1078. {
  1079.           total += ret;
  1080.   FD_SET(realfd, &fdr);
  1081.   FD_SET(realfd, &fdw); 
  1082. }
  1084.   if (total >= max_len)
  1085.     return total;
  1086.       if (ret <= 0)
  1087. {
  1088.   err = SSL_get_error(fp->ssl, ret);
  1089.   FD_ZERO(&fdr); 
  1090.   FD_ZERO(&fdw);
  1091.   switch (err)
  1092.    {
  1093.     case SSL_ERROR_WANT_READ:
  1094. #if DEBUG_SSL > 2
  1095.       fprintf(stderr, "SSL_read[%d]: SSL_ERROR_WANT_READn", getpid());
  1096. #endif
  1097.       FD_SET(realfd, &fdr);
  1098.       break;
  1099.     case SSL_ERROR_WANT_WRITE:
  1100. #if DEBUG_SSL > 2
  1101.       fprintf(stderr, "SSL_Connect[%d]: SSL_ERROR_WANT_WRITEn", getpid());
  1102. #endif
  1103.       FD_SET(realfd, &fdr);
  1104.       FD_SET(realfd, &fdw);
  1105.       break;
  1107.     case SSL_ERROR_ZERO_RETURN:
  1108. #if DEBUG_SSL > 2
  1109.       fprintf(stderr, "SSL_Connect[%d]: SSL_ERROR_ZERO_RETURNn", getpid());
  1110. #endif
  1111.       fp->last_err = EPIPE;
  1112.       return total;
  1114.     default:
  1115. #if DEBUG_SSL > 0
  1116.       sslerror2("SSL_read", err);
  1117. #endif
  1118.       fp->last_err = EPIPE;
  1119.       return total;
  1120.     }
  1121. }
  1122.     }
  1124.     if (min_len <= 0)
  1125.       {
  1126. /* Be smart */
  1127. if (total > 0 && flag)
  1128.   return total;
  1129. else
  1130.   flag ++;
  1131.       }
  1132.   else if (total >= min_len)
  1133. return total;
  1134. }
  1135.       if ( t >= timeout ) fp->last_err = ETIMEDOUT;
  1136.       return total;
  1137. #endif
  1138.     default :
  1139.       if (fp->transport != -1 || fp->fd != 0)
  1140. fprintf(stderr, "Severe bug! Unhandled transport layer %d (fd=%d)n",
  1141. fp->transport, fd);
  1142.       else
  1143. fprintf(stderr, "read_stream_connection_unbuffered: fd=%d is closedn", fd);
  1144.       errno = EINVAL;
  1145.       return -1;
  1146.     }
  1147.   /*NOTREACHED*/
  1148. }
  1150. ExtFunc int 
  1151. read_stream_connection_min(fd, buf0, min_len, max_len)
  1152.  int fd;
  1153.  void* buf0;
  1154.  int min_len, max_len;
  1155. {
  1156.   nessus_connection *fp;
  1158.   if (NESSUS_STREAM(fd))
  1159.     {
  1160.       fp = &(connections[fd - NESSUS_FD_OFF]);
  1161.       if (fp->buf != NULL)
  1162. {
  1163.   int l1, l2;
  1165.   if (max_len == 1) min_len = 1; /* avoid "magic read" later */
  1166.   l2 = max_len > fp->bufcnt ? fp->bufcnt : max_len;
  1167.   if (l2 > 0)
  1168.     {
  1169.       memcpy(buf0, fp->buf + fp->bufptr, l2);
  1170.       fp->bufcnt -= l2;
  1171.       if (fp->bufcnt == 0)
  1172. {
  1173.   fp->bufptr = 0;
  1174.   fp->buf[0] = ''; /* debug */
  1175. }
  1176.       else
  1177. fp->bufptr += l2;
  1178.       if (l2 >= min_len || l2 >= max_len)
  1179. return l2;
  1180.       max_len -= l2;
  1181.       min_len -= l2;
  1182.     }
  1183.   if (min_len > fp->bufsz)
  1184.     {
  1185.       l1 = read_stream_connection_unbuffered(fd, (char*)buf0 + l2,
  1186.      min_len, max_len);
  1187.       if (l1 > 0)
  1188. return l1 + l2;
  1189.       else
  1190. return l2;
  1191.     }
  1192.   /* Fill buffer */
  1193.   l1 = read_stream_connection_unbuffered(fd, fp->buf, min_len, fp->bufsz);
  1194.   if (l1 <= 0)
  1195.     return l2;
  1196.   
  1197.   fp->bufcnt = l1;
  1198.   l1 = max_len > fp->bufcnt ? fp->bufcnt : max_len;
  1199.   memcpy((char*)buf0 + l2, fp->buf + fp->bufptr, l1);
  1200.   fp->bufcnt -= l1;
  1201.   if (fp->bufcnt == 0)
  1202.     fp->bufptr = 0;
  1203.   else
  1204.     fp->bufptr += l1;
  1205.   return l1 + l2;
  1206. }
  1207.     }
  1208.   return read_stream_connection_unbuffered(fd, buf0, min_len, max_len);
  1209. }
  1211. ExtFunc int 
  1212. read_stream_connection(fd, buf0, len)
  1213.  int fd;
  1214.  void* buf0;
  1215.  int len;
  1216. {
  1217.  return read_stream_connection_min(fd, buf0, -1, len);
  1218. }
  1220. static int
  1221. write_stream_connection4(fd, buf0, n, i_opt) 
  1222.  int fd;
  1223.  void * buf0;
  1224.  int n;
  1225.  int i_opt;
  1226. {
  1227.   int err, ret, count;
  1228.  unsigned char* buf = (unsigned char*)buf0;
  1229.  nessus_connection * fp;
  1230.   fd_set fdr, fdw;
  1231.   struct timeval tv;
  1232.   int e;
  1234.  if(!NESSUS_STREAM(fd))
  1235.    {
  1236. #if DEBUG_SSL > 0
  1237.      fprintf(stderr, "write_stream_connection: fd <%d> invalidn", fd);
  1238. # if 0
  1239.      abort();
  1240. # endif
  1241. #endif
  1242.      errno = EINVAL;
  1243.      return -1;
  1244.     }
  1246.  fp = &(connections[fd - NESSUS_FD_OFF]);
  1247.  fp->last_err = 0;
  1248.  
  1249. #if DEBUG_SSL > 8
  1250.  fprintf(stderr, "> write_stream_connection(%d, 0x%x, %d, 0x%x) tE=%d 0=0x%xn",
  1251.  fd, buf, n, i_opt, fp->transport, fp->options);
  1252. #endif
  1254.  switch(fp->transport)
  1255.  {
  1256.   case NESSUS_ENCAPS_IP:
  1257.    for(count = 0; count < n;)
  1258.    {
  1259.      if ((fp->options & NESSUS_CNX_IDS_EVASION_SEND_MASK) != 0)
  1260.      {
  1261.       if(fp->options & NESSUS_CNX_IDS_EVASION_SPLIT)
  1262.        /* IDS evasion */
  1263.        ret = send(fp->fd, buf + count, 1, i_opt);
  1264.      else 
  1265.        /* i_opt ignored for ids_send */
  1266.       ret = ids_send(fp->fd, buf + count, n - count, fp->options);
  1267.      }
  1268.      else
  1269.        ret = send(fp->fd, buf + count, n - count, i_opt);
  1271.     if(ret <= 0)
  1272.       {
  1273.        if ( ret < 0 ) fp->last_err = errno;
  1274.        else fp->last_err = EPIPE;
  1275.        break;
  1276.       }
  1277.      
  1278.      count += ret;
  1279.     }
  1280.     break;
  1282. #ifdef HAVE_SSL
  1283.   case NESSUS_ENCAPS_SSLv2:
  1284.   case NESSUS_ENCAPS_SSLv23:
  1285.   case NESSUS_ENCAPS_SSLv3:
  1286.   case NESSUS_ENCAPS_TLSv1:
  1287.       FD_ZERO(&fdr); FD_ZERO(&fdw); 
  1288.       FD_SET(fp->fd, & fdr); FD_SET(fp->fd, & fdw);
  1290.       /* i_opt ignored for SSL */
  1291.     for(count = 0; count < n;)
  1292.     { 
  1293.      ret = SSL_write(fp->ssl, buf + count, n - count);
  1294.   if (ret > 0)
  1295.     count += ret;
  1296.   else
  1297.     {
  1298.       fp->last_ssl_err = err = SSL_get_error(fp->ssl, ret);
  1299.       FD_ZERO(&fdw); FD_ZERO(&fdr); 
  1300.       if (err == SSL_ERROR_WANT_WRITE)
  1301. {
  1302.   FD_SET(fp->fd, &fdw);
  1303. #if DEBUG_SSL > 2
  1304.   fprintf(stderr, "SSL_write[%d]: SSL_ERROR_WANT_WRITEn", getpid());
  1305. #endif    
  1306.      }
  1307.       else if (err == SSL_ERROR_WANT_READ)
  1308. {
  1309. #if DEBUG_SSL > 2
  1310.   fprintf(stderr, "SSL_write[%d]: SSL_ERROR_WANT_READn", getpid());
  1311. #endif
  1312.   FD_SET(fp->fd, &fdr);
  1313. }
  1314.       else
  1315.      { 
  1316. #if DEBUG_SSL > 0
  1317.   sslerror2("SSL_write", err);
  1318. #endif      
  1319.   fp->last_err = EPIPE;
  1320.    break;
  1321.      }
  1322.       if (fp->timeout >= 0)
  1323. tv.tv_sec = fp->timeout;
  1324.      else 
  1325. tv.tv_sec = TIMEOUT;
  1327.       tv.tv_usec = 0;
  1328.         do {
  1329.         errno = 0;
  1330.       e = select(fp->fd+1, &fdr, &fdw, NULL, &tv);
  1331.         } while ( e < 0 && errno == EINTR );
  1333.     if ( e <= 0 )
  1334. {
  1335. #if DEBUG_SSL > 0
  1336.   nessus_perror("select");
  1337. #endif
  1338.   fp->last_err = ETIMEDOUT;
  1339.   break;
  1340. }
  1341.     }
  1342.      }
  1343.     break;
  1344. #endif
  1345.    default:
  1346.      if (fp->transport != -1 || fp->fd != 0)
  1347.        fprintf(stderr, "Severe bug! Unhandled transport layer %d (fd=%d)n",
  1348.        fp->transport, fd);
  1349.      else
  1350.        fprintf(stderr, "read_stream_connection_unbuffered: fd=%d is closedn", fd);
  1351.      errno =EINVAL;
  1352.      return -1;
  1353.   }
  1354.   
  1355.   
  1356.   if(count == 0 && n > 0)
  1357.    return -1;
  1358.   else 
  1359.    return count;
  1360. }
  1362. ExtFunc int
  1363. write_stream_connection(fd, buf0, n) 
  1364.  int fd;
  1365.  void * buf0;
  1366.  int n;
  1367. {
  1368.   return write_stream_connection4(fd, buf0, n, 0);
  1369. }
  1371. ExtFunc int
  1372. nsend (fd, data, length, i_opt)
  1373.  int fd;
  1374.  void * data;
  1375.  int length, i_opt;
  1376. {
  1377.   int n = 0;
  1379.  if(NESSUS_STREAM(fd))
  1380.  {
  1381.   if(connections[fd - NESSUS_FD_OFF].fd < 0)
  1382.    fprintf(stderr, "Nessus file descriptor %d closed ?!n", fd);
  1383.   else 
  1384.     return write_stream_connection4(fd, data, length, i_opt);
  1385.  }
  1386. #if DEBUG_SSL > 1
  1387.  else
  1388.    fprintf(stderr, "nsend[%d]: fd=%dn", getpid(), fd);
  1389. #endif
  1390. #if 0
  1391.    for (i = 0; i < NESSUS_FD_MAX; i ++)
  1392.      if (connections[i].fd == fd && connections[i].transport > 0)
  1393.        {
  1394.  /* Fixing a severe bug! */
  1395.  fprintf(stderr, "nsend: fd=%d used by Nessus FD %dn",
  1396.  fd, i + NESSUS_FD_OFF);
  1397.  return write_stream_connection4(i + NESSUS_FD_OFF, data, length, i_opt);
  1398.        }
  1399. #endif
  1400.  /* Trying OS's send() */
  1401.    block_socket(fd); /* ??? */
  1402.    do
  1403.  {
  1404.        struct timeval tv = {0,5};
  1405.        fd_set wr;
  1406.        int e;
  1407.        
  1408.        FD_ZERO(&wr);
  1409.        FD_SET(fd, &wr);
  1410.        
  1411.        errno = 0;
  1412.        e  = select(fd + 1, NULL, &wr, NULL, &tv);
  1413.        if ( e > 0 )
  1414.         n = os_send(fd, data, length, i_opt);
  1415.        else if ( e < 0 && errno == EINTR ) continue;
  1416.        else break;
  1417.      }
  1418.    while (n <= 0 && errno == EINTR);
  1419.    if (n < 0)
  1420.      fprintf(stderr, "[%d] nsend():send %sn", getpid(), strerror(errno));
  1421.    return n;
  1422.  }
  1423.  
  1424. ExtFunc int
  1425. nrecv (fd, data, length, i_opt)
  1426.  int fd;
  1427.  void * data;
  1428.  int length, i_opt;
  1429. {
  1430.   int e;
  1431. #if DEBUG_SSL > 8
  1432.    fprintf(stderr, "nrecv: fd=%d len=%dn", fd, length);
  1433. #endif
  1434.  if(NESSUS_STREAM(fd))
  1435.  {
  1436.   if(connections[fd - NESSUS_FD_OFF].fd < 0)
  1437.    fprintf(stderr, "Nessus file descriptor %d closed ?!n", fd);
  1438.   else 
  1439.     return read_stream_connection(fd, data, length);
  1440.  }
  1441.  /* Trying OS's recv() 
  1442.   *
  1443.   * Do *NOT* use os_recv() here, as it will be blocking until the exact
  1444.   * amount of requested data arrives
  1445.   */
  1446.  block_socket(fd);
  1447.  do {
  1448. e = recv(fd, data, length, i_opt);
  1449.  } while ( e < 0 && errno == EINTR );
  1450.  return e;
  1451. }
  1452.  
  1454. ExtFunc int
  1455. close_stream_connection(fd)
  1456.  int fd;
  1457. {
  1458. #if DEBUG_SSL > 2
  1459.  nessus_connection * fp;
  1460.  if(!NESSUS_STREAM(fd))
  1461.     {
  1462.      errno = EINVAL;
  1463.      return -1;
  1464.     }
  1465.   fp = &(connections[fd - NESSUS_FD_OFF]);
  1466.   fprintf(stderr, "close_stream_connection TCP:%dn", fp->port);
  1467. #endif
  1469.   if(!NESSUS_STREAM(fd)) /* Will never happen if debug is on! */
  1470.    {
  1471.     if ( fd < 0 || fd > 1024 )
  1472.     {
  1473.    errno = EINVAL;
  1474.    return -1;
  1475.     }
  1476.    shutdown(fd, 2);
  1477.    return socket_close(fd);
  1478.    }
  1479.   else
  1480.    return release_connection_fd(fd);
  1481. }
  1484. ExtFunc int
  1485. get_encaps(fd)
  1486.  int fd;
  1487. {
  1488.  if(!NESSUS_STREAM(fd))
  1489.  {
  1490.    fprintf(stderr, "get_encaps() : bad argumentn");
  1491.    return -1;
  1492.  }
  1493.  return connections[fd - NESSUS_FD_OFF].transport;
  1494. }
  1497.  
  1498. ExtFunc const char *
  1499. get_encaps_name(code)
  1500.  int code;
  1501. {
  1502.  static char str[100];
  1503.  switch(code)
  1504.  {
  1505.   case NESSUS_ENCAPS_IP:
  1506.    return "IP";
  1507.   case NESSUS_ENCAPS_SSLv2:
  1508.     return "SSLv2";
  1509.   case NESSUS_ENCAPS_SSLv23:
  1510.     return "SSLv23";
  1511.   case NESSUS_ENCAPS_SSLv3:
  1512.     return "SSLv3";
  1513.   case NESSUS_ENCAPS_TLSv1:
  1514.     return "TLSv1";
  1515.   default:
  1516.    snprintf(str, sizeof(str), "[unknown transport layer - code %d (0x%x)]", code, code);
  1517.    return str;
  1518.  }
  1519. }
  1521. ExtFunc  const char *
  1522. get_encaps_through(code)
  1523.  int code;
  1524. {
  1525.  static char str[100];
  1526.  switch(code)
  1527.  {
  1528.   case NESSUS_ENCAPS_IP:
  1529.    return "";
  1530.   case NESSUS_ENCAPS_SSLv2:
  1531.   case NESSUS_ENCAPS_SSLv23:
  1532.   case NESSUS_ENCAPS_SSLv3:
  1533.   case NESSUS_ENCAPS_TLSv1:
  1534.     return " through SSL";
  1535.   default:
  1536.     snprintf(str, sizeof(str), " through unknown transport layer - code %d (0x%x)", code, code);
  1537.     return str;
  1538.  }
  1539. }
  1541. static int
  1542. open_socket(struct sockaddr_in *paddr, 
  1543.     int port, int type, int protocol, int timeout)
  1544. {
  1545.   fd_set fd_w;
  1546.   struct timeval to;
  1547.   int soc, x;
  1548.   int opt;
  1549.   unsigned int opt_sz;
  1551.   __port_closed = 0;
  1553.   if ((soc = socket(AF_INET, type, protocol)) < 0)
  1554.     {
  1555.       nessus_perror("socket");
  1556.       return -1;
  1557.     }
  1559.   if (timeout == -2)
  1560.     timeout = TIMEOUT;
  1562.   if (timeout > 0)
  1563.     if (unblock_socket(soc) < 0)
  1564.       {
  1565. closesocket(soc);
  1566. return -1;
  1567.       }
  1569.   set_socket_source_addr(soc, 0);
  1571. #if defined NESSUS_CNX_LOCK
  1572.   if (lock_cnt == 0)
  1573. {
  1574.       lock_fd = open(NESSUS_CNX_LOCK, O_RDWR|O_CREAT);
  1575.       if (lock_fd < 0)
  1576. nessus_perror(NESSUS_CNX_LOCK);
  1577.       else
  1578. {
  1579.   time_t t1 = time(NULL), t2;
  1580.   if (flock(lock_fd, LOCK_EX) < 0)
  1581.     nessus_perror(NESSUS_CNX_LOCK);
  1582.   else
  1583.     {
  1584.       lock_cnt ++;
  1585.       t2 = time(NULL);
  1586. #if 1
  1587.       if (t2 - t1 > 0)
  1588. fprintf(stderr, "[%d] open_socket: " NESSUS_CNX_LOCK " locked in %d sn", getpid(), t2 - t1);
  1589. #endif
  1590.     }
  1591. }
  1592.     }
  1593.   else
  1594.     {
  1595. #if 1
  1596.       fprintf(stderr, "[%d] open_socket: sleeping 1 secondn", getpid());
  1597. #endif
  1598.       sleep(1);
  1599.     }
  1600. #endif  
  1601.   
  1602.   if (connect(soc, (struct sockaddr*) paddr, sizeof(*paddr)) < 0)
  1603.     {
  1604. #if debug_SSL > 2
  1605.       nessus_perror("connect");
  1606. #endif
  1607. again:
  1608.       switch (errno)
  1609. {
  1610. case EINPROGRESS:
  1611. case EAGAIN:
  1612.   FD_ZERO(&fd_w);
  1613.   FD_SET(soc, &fd_w);
  1614.   to.tv_sec = timeout;
  1615.   to.tv_usec = 0;
  1616.   x = select(soc + 1, NULL, &fd_w, NULL, &to);
  1617.   if (x == 0)
  1618.     {
  1619. #if debug_SSL > 2
  1620.       nessus_perror("connect->select: timeout");
  1621. #endif
  1622.       socket_close(soc);
  1623.       errno = ETIMEDOUT;
  1624.       return -1;
  1625.     }
  1626.   else if (x < 0)
  1627.     {
  1628.       if ( errno == EINTR )
  1629.                {
  1630.    errno = EAGAIN;
  1631.  goto again;
  1632.        }
  1633.       nessus_perror("select");
  1634.       socket_close(soc);
  1635.       return -1;
  1636.             }
  1637.  
  1638.   opt = 0; opt_sz = sizeof(opt);
  1639.   if (getsockopt(soc, SOL_SOCKET, SO_ERROR, &opt, &opt_sz) < 0)
  1640.     {
  1641.       nessus_perror("getsockopt");
  1642.       socket_close(soc);
  1643.       return -1;
  1644.     }
  1645.   if (opt == 0)
  1646.     break;
  1647. #if DEBUG_SSL > 2
  1648.   errno = opt;
  1649.   nessus_perror("SO_ERROR");
  1650. #endif
  1651.   /* no break; go on */   
  1652. default:
  1653.   __port_closed = 1;
  1654.   socket_close(soc);
  1655.   return  -1;
  1656. }
  1657.     }
  1658.   block_socket(soc);
  1659.   return soc;
  1660. }
  1663. ExtFunc 
  1664. int open_sock_opt_hn(hostname, port, type, protocol, timeout)
  1665.  const char * hostname; 
  1666.  unsigned int port; 
  1667.  int type;
  1668.  int protocol;
  1669.  int timeout;
  1670. {
  1671.  struct sockaddr_in addr;
  1672.   
  1673.   bzero((void*)&addr, sizeof(addr));
  1674.   addr.sin_family=AF_INET;
  1675.   addr.sin_port=htons((unsigned short)port);
  1676.   addr.sin_addr = nn_resolve(hostname);
  1677.   if (addr.sin_addr.s_addr == INADDR_NONE || addr.sin_addr.s_addr == 0)
  1678.     {
  1679.       fprintf(stderr, "open_sock_opt_hn: invalid socket addressn");
  1680.       return  -1;
  1681.     }
  1682.    
  1683.   return open_socket(&addr, port, type, protocol, timeout);
  1684. }
  1687. ExtFunc
  1688. int open_sock_tcp_hn(hostname, port)
  1689.  const char * hostname;
  1690.  unsigned int port;
  1691. {
  1692.   return open_sock_opt_hn(hostname, port, SOCK_STREAM, IPPROTO_TCP, TIMEOUT);
  1693. }
  1697. ExtFunc
  1698. int open_sock_tcp(args, port, timeout)
  1699.  struct arglist * args; 
  1700.  unsigned int port;
  1701.  int timeout;
  1702. {
  1703.   char name[32];
  1704.   int ret;
  1705.   int type;
  1706.   
  1708.   /*
  1709.    * If we timed out against this port in the past, there's no need
  1710.    * to scan it again
  1711.    */
  1712.   snprintf(name, sizeof(name), "/tmp/ConnectTimeout/TCP/%d", port);
  1713.   if ( plug_get_key ( args, name, &type ) ) 
  1714. return -1;
  1717.   errno = 0;
  1718.   ret  = open_sock_option(args, port, SOCK_STREAM,IPPROTO_TCP, timeout);
  1719.   if ( ret < 0 && errno == ETIMEDOUT )
  1720.     plug_set_key( args, name, ARG_INT, (void*)1); 
  1722.   return ret;
  1723. }
  1726. ExtFunc
  1727. int open_sock_udp(args, port)
  1728.  struct arglist * args;
  1729.  unsigned int port;
  1730. {
  1731.   return open_sock_option(args, port, SOCK_DGRAM, IPPROTO_UDP, 0);
  1732. }
  1735. ExtFunc 
  1736. struct in_addr _socket_get_next_source_addr(struct in_addr * addr)
  1737. {
  1738.   static struct in_addr * src_addrs = NULL;
  1739.   static int current_src_addr = 0;
  1740.   static pid_t current_src_addr_pid = 0;
  1741.   static int num_addrs = 0;
  1742.   struct in_addr ret;
  1743.   pid_t mypid;
  1744.   
  1745.   if( current_src_addr < 0 )
  1746.   {
  1747.    ret.s_addr = INADDR_ANY;
  1748.    return ret;
  1749.   }
  1750.   
  1751.   
  1752.   
  1753.   if ( src_addrs == NULL && current_src_addr == 0 )
  1754.   {
  1755.     src_addrs = addr;
  1756.     if( src_addrs == NULL ) 
  1757.     {
  1758.      ret.s_addr = INADDR_ANY;
  1759.      current_src_addr = -1;
  1760.      return ret;
  1761.     }    
  1762.    
  1763.    num_addrs = -1;
  1764.    while(src_addrs[++num_addrs].s_addr != 0 ) ;
  1765.   }
  1766.   
  1767.   
  1768.   mypid = getpid();
  1769.   if ( current_src_addr_pid != mypid )
  1770.    {
  1771.     current_src_addr_pid = mypid;
  1772.     current_src_addr = lrand48() % ( num_addrs ) ;
  1773.     if ( src_addrs[current_src_addr].s_addr == 0 ) current_src_addr = 0;
  1774.    }
  1775.   
  1776.   return src_addrs[current_src_addr];
  1777. }
  1779. ExtFunc
  1780. struct in_addr socket_get_next_source_addr()
  1781. {
  1782.  return _socket_get_next_source_addr(NULL);
  1783. }
  1785. ExtFunc 
  1786. int set_socket_source_addr(int soc, int port)
  1787. { 
  1788.   struct sockaddr_in bnd;
  1789.   int opt = 1;  
  1790.   
  1791.   struct in_addr src = _socket_get_next_source_addr(NULL);
  1792.   
  1793.   if( src.s_addr == INADDR_ANY && port == 0 ) /* No need to bind() */
  1794.    return 0;
  1795.    
  1796.   setsockopt(soc, SOL_SOCKET, SO_REUSEADDR, (void*)&opt, sizeof(int));
  1797.   bzero(&bnd, sizeof(bnd));
  1798.   
  1799.    
  1800.    
  1801.    bnd.sin_port = htons(port);
  1802.    bnd.sin_addr = src;
  1803.    bnd.sin_family = AF_INET;
  1804.   
  1805.   if( bind(soc, (struct sockaddr*)&bnd, sizeof(bnd)) < 0 )
  1806.   { 
  1807.    return -1;
  1808.   }
  1809.   
  1810.   return 0;
  1811. }
  1813. ExtFunc  void socket_source_init(struct in_addr * addr)
  1814. {
  1815.  (void) _socket_get_next_source_addr(addr);
  1816. }
  1819. ExtFunc
  1820. int open_sock_option(args, port, type, protocol, timeout)
  1821.  struct arglist * args;
  1822.  unsigned int port;
  1823.  int type;
  1824.  int protocol;
  1825.  int timeout;
  1826. {
  1827.   struct sockaddr_in addr;
  1828.   struct in_addr * t;
  1830. #if 0
  1831.   /* 
  1832.    * MA 2004-08-15: IMHO, as this is often (always?) tested in the NASL scripts
  1833.    * this should not be here. 
  1834.    * If it has to be somewhere else, I'd rather put it in libnasl (and add
  1835.    * a parameter to "force" the connection)
  1836.    */
  1837.   if(host_get_port_state(args, port)<=0)return(-1);
  1838. #endif
  1839.   bzero((void*)&addr, sizeof(addr));
  1840.   addr.sin_family=AF_INET;
  1841.   addr.sin_port=htons((unsigned short)port);
  1842.   t = plug_get_host_ip(args);
  1843.   if(!t)
  1844.   {
  1845.    fprintf(stderr, "ERROR ! NO ADDRESS ASSOCIATED WITH NAMEn");
  1846.    arg_dump(args, 0);
  1847.    return(-1);
  1848.   }
  1849.   addr.sin_addr = *t;
  1850.   if (addr.sin_addr.s_addr == INADDR_NONE)
  1851.     return(-1);
  1852.     
  1853.   return open_socket(&addr, port, type, protocol, timeout);
  1854. }
  1857. /* This function reads a text from the socket stream into the
  1858.    argument buffer, always appending a '' byte.  The return
  1859.    value is the number of bytes read, without the trailing ''.
  1860.  */
  1863. ExtFunc
  1864. int recv_line(soc, buf, bufsiz)
  1865.  int soc;
  1866.  char * buf;
  1867.  size_t bufsiz;
  1868. {
  1869.   int n, ret = 0;
  1870.   
  1871.   /*
  1872.    * Dirty SSL hack
  1873.    */
  1874.   if(NESSUS_STREAM(soc))
  1875.   {
  1876.    buf[0] = '';
  1877.    
  1878.    do
  1879.    {
  1880.     n = read_stream_connection_min (soc, buf + ret, 1, 1);
  1881.     switch (n)
  1882.     {
  1883.      case -1 :
  1884.        if(ret == 0)
  1885.         return -1;
  1886.        else 
  1887.         return ret;
  1888.        break;
  1889.      
  1890.      case 0:
  1891.        return ret;
  1892.        break;
  1893.       
  1894.       default :
  1895.        ret ++;
  1896.     }
  1897.    }
  1898.    while (buf [ret-1] != '' && buf [ret-1] != 'n' && ret < bufsiz) ;
  1899.    
  1900.    if(ret > 0 )
  1901.    {
  1902.    if (buf[ret - 1] != '')
  1903. {
  1904. if ( ret < bufsiz ) 
  1905. buf[ ret ] = '';
  1906. else 
  1907. buf [ bufsiz - 1 ] = '';
  1908. }
  1909.    }
  1910.    return ret;  
  1911.   }
  1912.   else
  1913.   {
  1914.    fd_set rd;
  1915.    struct timeval tv;
  1916.    
  1917.    do
  1918.    {
  1919.       int e;
  1920.  again:
  1921.       errno = 0;
  1922.       FD_ZERO(&rd);
  1923.       FD_SET(soc, &rd);
  1924.       tv.tv_sec = 5;
  1925.       tv.tv_usec = 0;
  1926.       e = select(soc+1, &rd, NULL, NULL, &tv); 
  1927.       if( e < 0 && errno == EINTR) goto again;
  1928.       if( e > 0 )
  1929.       {
  1930.        n = recv(soc, buf + ret, 1, 0);
  1931.        switch(n)
  1932.        {
  1933.         case -1 :
  1934.  if ( errno == EINTR ) continue;
  1935.  if(ret == 0)
  1936.   return -1;
  1937.  else
  1938.   return ret;
  1939.  break;  
  1940.        case 0 :
  1941.          return ret;
  1942.          break;
  1943.        default:
  1944.          ret ++;
  1945.        }
  1946.       } 
  1947.       else break;
  1948.       tv.tv_sec = 1;
  1949.       tv.tv_usec = 0;
  1950.     } while(buf[ret -1 ] != '' && buf[ret -1 ] != 'n' && ret < bufsiz);
  1951.     
  1952.     if(ret > 0)
  1953.     {
  1954.     if(buf[ret - 1] != '')
  1955.       {
  1956. if ( ret < bufsiz )
  1957.        buf[ret] = '';
  1958. else
  1959. buf[bufsiz - 1] = '';
  1960.       }
  1961.     }
  1962.   }
  1963.   return ret;
  1964. } 
  1966. ExtFunc int
  1967. socket_close(soc)
  1968. int soc;
  1969. {
  1970. #if defined NESSUS_CNX_LOCK
  1971.   if (lock_cnt > 0)
  1972.     if (-- lock_cnt == 0)
  1973.       {
  1974. if (flock(lock_fd, LOCK_UN) < 0)
  1975.   nessus_perror(NESSUS_CNX_LOCK);
  1976. if (close(lock_fd) < 0)
  1977.   nessus_perror(NESSUS_CNX_LOCK);
  1978. lock_fd = -1;
  1979.       }
  1980. #endif  
  1981.   return closesocket(soc);
  1982. }
  1984. /*
  1985.  * auth_printf()
  1986.  *
  1987.  * Writes data to the global socket of the thread
  1988.  */
  1989. ExtFunc void 
  1990. auth_printf(struct arglist * globals, char * data, ...)
  1991. {
  1992.   va_list param;
  1993.   char buffer[65535];
  1994.   
  1995.   bzero(buffer, sizeof(buffer));
  1997.   va_start(param, data);
  1998.   vsnprintf(buffer, sizeof(buffer) - 1, data, param);
  1999.   
  2000.   va_end(param);
  2001.   auth_send(globals, buffer);
  2002. }                    
  2005. ExtFunc void
  2006. auth_send(struct arglist * globals, char * data)
  2007. {
  2008.  int soc = (int)arg_get_value(globals, "global_socket");
  2009.  int confirm = (int)arg_get_value(globals, "confirm");
  2010.  int n = 0;
  2011.  int length;
  2012.  int sent = 0;
  2014.  if(soc < 0)
  2015.   return;
  2017. #ifndef NESSUSNT
  2018.  signal(SIGPIPE, _exit);
  2019. #endif
  2020.  length = strlen(data);
  2021.  while(sent < length)
  2022.  {
  2023.  n = nsend(soc, data+sent, length-sent, 0);
  2024.  if(n < 0)
  2025.  {
  2026.   if((errno == ENOMEM)
  2027. #ifdef ENOBUFS  
  2028.    ||(errno==ENOBUFS)
  2029. #endif   
  2030.    )
  2031.    n = 0;
  2032.   else
  2033.    {
  2034.    nessus_perror("nsend");
  2035.    goto out;
  2036.    }
  2037.  }
  2038.  else sent+=n;
  2039.  }
  2040.  
  2041.  if(confirm)
  2042.  {
  2043.   /*
  2044.    * If confirm is set, then we are a son
  2045.    * trying to report some message to our busy
  2046.    * father. So we wait until he told us he
  2047.    * took care of it
  2048.    */
  2049.   char n;
  2050.   read_stream_connection_min(soc, &n, 1, 1);
  2051.  }
  2052. out:
  2053. #ifndef NESSUSNT
  2054.   signal(SIGPIPE, SIG_IGN);
  2055. #else
  2056.  ;
  2057. #endif
  2058. }
  2060. /*
  2061.  * auth_gets()
  2062.  *
  2063.  * Reads data from the global socket of the thread
  2064.  */
  2065. ExtFunc char * 
  2066. auth_gets(globals, buf, bufsiz)
  2067.      struct arglist * globals;
  2068.      char * buf;
  2069.      size_t bufsiz;
  2070. {
  2071.   int soc = (int)arg_get_value(globals, "global_socket");
  2072.   int n;
  2073.   /* bzero(buf, bufsiz); */
  2074.   n = recv_line(soc, buf, bufsiz);
  2075.   if(n <= 0)
  2076.   return NULL;
  2077.   
  2078.   return(buf);
  2079. }
  2082. /*
  2083.  * Select() routines
  2084.  */
  2085.  
  2086. ExtFunc int
  2087. stream_zero(set)
  2088.  fd_set * set;
  2089. { 
  2090.  FD_ZERO(set);
  2091.  return 0;
  2092. }
  2094. ExtFunc int
  2095. stream_set(fd, set)
  2096.  int fd;
  2097.  fd_set * set;
  2098. {
  2099.  int soc = nessus_get_socket_from_connection(fd);
  2100.  if(soc >= 0)
  2101.   FD_SET(soc, set);
  2102.  return soc;
  2103. }
  2105. ExtFunc int
  2106. stream_isset(fd, set)
  2107.  int fd;
  2108.  fd_set * set;
  2109. {
  2110.  return FD_ISSET(nessus_get_socket_from_connection(fd), set);
  2111. }
  2113. ExtFunc int
  2114. fd_is_stream(fd)
  2115.      int fd;
  2116. {
  2117.   return NESSUS_STREAM(fd); /* Should probably be smarter... */
  2118. }
  2121. ExtFunc int 
  2122. stream_get_buffer_sz ( int fd )
  2123. {
  2124.   nessus_connection *p;
  2125.   if (! NESSUS_STREAM(fd))
  2126.     return -1;
  2127.   p = &(connections[fd - NESSUS_FD_OFF]);
  2128.   return p->bufsz;
  2129. }
  2132. ExtFunc int
  2133. stream_set_buffer(fd, sz)
  2134.      int fd, sz;
  2135. {
  2136.   nessus_connection *p;
  2137.   char *b;
  2139.   if (! NESSUS_STREAM(fd))
  2140.     return -1;
  2142.   p = &(connections[fd - NESSUS_FD_OFF]);
  2143.   if (sz < p->bufcnt)
  2144.       return -1; /* Do not want to lose data */
  2146.   if (sz == 0)
  2147.     {
  2148.       efree(&p->buf);
  2149.       p->bufsz = 0;
  2150.       return 0;
  2151.     }
  2152.   else if (p->buf == 0)
  2153.     {
  2154.       p->buf = malloc(sz);
  2155.       if (p->buf == NULL)
  2156. return -1;
  2157.       p->bufsz = sz;
  2158.       p->bufptr = 0;
  2159.       p->bufcnt = 0;
  2160.       return 0;
  2161.     }
  2162.   else
  2163.     {
  2164.       if (p->bufcnt > 0)
  2165. {
  2166.   memmove(p->buf, p->buf + p->bufptr, p->bufcnt);
  2167.   p->bufptr = 0;
  2168. }
  2169.       b = realloc(p->buf, sz);
  2170.       if (b == NULL)
  2171. return -1;
  2172.       p->bufsz = sz;
  2173.       return 0;
  2174.     }
  2175.   /*NOTREACHED*/
  2176. }
  2180. /*------------------------------------------------------------------*/
  2183. int os_send(int soc, void * buf, int len, int opt )
  2184. {
  2185.  char * buf0 = (char*)buf;
  2186.  int e, n;
  2187.  for ( n = 0 ; n < len ; ) 
  2188.  {
  2189.   errno = 0;
  2190.   e = send(soc, buf0 + n , len -  n, opt);
  2191.   if ( e < 0 && errno == EINTR ) continue; 
  2192.   else if ( e <= 0 ) return -1;
  2193.   else n += e;
  2194.  }
  2195.  return n;
  2196. }
  2198. int os_recv(int soc, void * buf, int len, int opt )
  2199. {
  2200.  char * buf0 = (char*)buf;
  2201.  int e, n;
  2202.  for ( n = 0 ; n < len ; ) 
  2203.  {
  2204.   errno = 0;
  2205.   e = recv(soc, buf0 + n , len -  n, opt);
  2206.   if ( e < 0 && errno == EINTR ) continue; 
  2207.   else if ( e <= 0 ) return -1;
  2208.   else n += e;
  2209.  }
  2210.  return n;
  2211. }
  2214. /* 
  2215.  * internal_send() / internal_recv() :
  2216.  *
  2217.  * When processes are passing messages to each other, the format is
  2218.  * <length><msg>, with <length> being a long integer. The functions
  2219.  * internal_send() and internal_recv() encapsulate and decapsulate
  2220.  * the messages themselves. 
  2221.  */
  2222. int internal_send(int soc, char * data, int msg_type )
  2223. {
  2224.  int len;
  2225.  int e;
  2226.  int ack;
  2227.  fd_set rd;
  2228.  struct timeval tv;
  2229.  
  2230.  if ( data == NULL )
  2231. data = "";
  2233.  e = os_send(soc, &msg_type, sizeof(len), 0 );
  2234.  if ( e < 0 ) return -1;
  2236.  if ( (msg_type & INTERNAL_COMM_MSG_TYPE_CTRL) == 0 )
  2237.   {
  2238.  len = strlen(data);
  2240.  e = os_send(soc, &len, sizeof(len), 0 );
  2241.  if ( e < 0 ) return -1;
  2242.  e = os_send(soc, data, len, 0 );
  2243.  if ( e < 0 ) return -1;
  2244.  }
  2246.  e = os_recv(soc, &ack, sizeof(ack), 0);
  2247.  if ( e < 0 ){
  2248. fprintf(stderr, "internal_send->os_recv(%d): %sn",soc, strerror(errno));
  2249. return -1;
  2250. }
  2252.  return 0;
  2253. }
  2256. int internal_recv(int soc, char ** data, int * data_sz, int * msg_type )
  2257. {
  2258.  int len = 0;
  2259.  int e;
  2260.  char * buf = *data;
  2261.  int    sz  = *data_sz;
  2262.  fd_set rd;
  2263.  struct timeval tv;
  2264.  int type;
  2265.  int ack;
  2266.  
  2267.  if ( buf == NULL )
  2268.  {
  2269.   sz = 65535;
  2270.   buf = emalloc ( sz );
  2271.  }
  2273.    
  2274.  e = os_recv(soc, &type, sizeof(type), 0 );
  2275.  if ( e < 0 ) goto error;
  2277.  if ( (type & INTERNAL_COMM_MSG_TYPE_CTRL) == 0 )
  2278.  {
  2279.  e = os_recv(soc, &len, sizeof(len), 0);
  2280.  if ( e < 0 ) goto error;
  2281.  
  2282.  if ( len >= sz )
  2283.  {
  2284.   sz = len + 1;
  2285.   buf = erealloc( buf, sz );
  2286.  }
  2288.  if ( len > 0 )
  2289.  {
  2290.  e = os_recv(soc, buf,len, 0);
  2291.  if ( e < 0 ) goto error;
  2292.  buf[len] = '';
  2293.  }
  2295.  if ( data != NULL )
  2296.   *data = buf;
  2297.  if ( data_sz != NULL )
  2298.   *data_sz = sz;
  2299.  }
  2300.  
  2301.  *msg_type = type;
  2302.  ack = INTERNAL_COMM_MSG_TYPE_CTRL | INTERNAL_COMM_CTRL_ACK;
  2303.  e = os_send(soc, &ack, sizeof(ack), 0);
  2304.  if ( e < 0 ) goto error;
  2306.  
  2307.  return len;
  2308. error:
  2309.  efree(&buf);
  2310.  *data = NULL;
  2311.  *data_sz = 0;
  2312.  return -1;
  2313. }
  2316. ExtFunc int stream_pending(int fd)
  2317. {
  2318.   nessus_connection * fp;
  2319.  if ( ! NESSUS_STREAM(fd) )
  2320.  {
  2321.   errno = EINVAL;
  2322.   return -1;
  2323.  }
  2324.  fp = &(connections[fd - NESSUS_FD_OFF]);
  2326.  if ( fp->bufcnt )
  2327.         return fp->bufcnt;
  2328. #ifdef HAVE_SSL
  2329.  else if ( fp->transport != NESSUS_ENCAPS_IP )
  2330.         return SSL_pending(fp->ssl);
  2331. #endif
  2332.  return 0;
  2333. }