int scanstream(int odesc, unsigned long int *scanned, const struct cl_node *root, const struct cl_limits *limits, int options, const struct cfgstruct *copt)
{
        int ret, portscan = 1000, sockfd, port = 0, acceptd;
        int tmpd, bread, retval, timeout, btread, min_port, max_port;
        long int size = 0, maxsize = 0;
        short bound = 0, rnd_port_first = 1;
        const char *virname;
        char buff[FILEBUFF];
        struct sockaddr_in server;
        struct hostent *he;
        struct cfgstruct *cpt;
        char *tmpname;


    /* get min port */
    min_port = cfgopt(copt, "StreamMinPort")->numarg;
    if(min_port < 1024 || min_port > 65535)
        min_port = 1024;

    /* get max port */
    max_port = cfgopt(copt, "StreamMaxPort")->numarg;
    if(max_port < min_port || max_port > 65535)
        max_port = 65535;

    /* bind to a free port */
    while(!bound && --portscan) {
        if(rnd_port_first) {
            /* try a random port first */
            port = min_port + cli_rndnum(max_port - min_port + 1);
            rnd_port_first = 0;
        } else {
            /* try the neighbor ports */
            if(--port < min_port)
                port=max_port;
        }

        memset((char *) &server, 0, sizeof(server));
        server.sin_family = AF_INET;
        server.sin_port = htons(port);

        if((cpt = cfgopt(copt, "TCPAddr"))->enabled) {
            pthread_mutex_lock(&gh_mutex);
            if((he = gethostbyname(cpt->strarg)) == 0) {
                logg("!gethostbyname(%s) error: %s\n", cpt->strarg);
                mdprintf(odesc, "gethostbyname(%s) ERROR\n", cpt->strarg);
                pthread_mutex_unlock(&gh_mutex);
                return -1;
            }
            server.sin_addr = *(struct in_addr *) he->h_addr_list[0];
            pthread_mutex_unlock(&gh_mutex);
        } else
            server.sin_addr.s_addr = INADDR_ANY;

        if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
            continue;

        if(bind(sockfd, (struct sockaddr *) &server, sizeof(struct sockaddr_in)) == -1)
            close(sockfd);
        else
            bound = 1;
    }

    timeout = cfgopt(copt, "ReadTimeout")->numarg;
    if(timeout == 0)
        timeout = -1;

    if(!bound && !portscan) {
        logg("!ScanStream: Can't find any free port.\n");
        mdprintf(odesc, "Can't find any free port. ERROR\n");
        close(sockfd);
        return -1;
    } else {
        listen(sockfd, 1);
        if(mdprintf(odesc, "PORT %d\n", port) <= 0) {
            logg("!ScanStream: error transmitting port.\n");
            close(sockfd);
            return -1;
        }
    }

    switch(retval = poll_fd(sockfd, timeout)) {
        case 0: /* timeout */
            mdprintf(odesc, "Accept timeout. ERROR\n");
            logg("!ScanStream %d: accept timeout.\n", port);
            close(sockfd);
            return -1;
        case -1:
            mdprintf(odesc, "Accept poll. ERROR\n");
            logg("!ScanStream %d: accept poll failed.\n", port);
            close(sockfd);
            return -1;
    }

    if((acceptd = accept(sockfd, NULL, NULL)) == -1) {
        close(sockfd);
        mdprintf(odesc, "accept() ERROR\n");
        logg("!ScanStream %d: accept() failed.\n", port);
        return -1;
    }

    logg("*Accepted connection on port %d, fd %d\n", port, acceptd);

    if ((tmpname = cli_gentempdesc(NULL, &tmpd)) == NULL) {
        shutdown(sockfd, 2);
        close(sockfd);
        close(acceptd);
        mdprintf(odesc, "tempfile() failed. ERROR\n");
        logg("!ScanStream %d: Can't create temporary file.\n", port);
        return -1;
    }

    maxsize = cfgopt(copt, "StreamMaxLength")->numarg;

    btread = sizeof(buff);

    while((retval = poll_fd(acceptd, timeout)) == 1) {
        bread = read(acceptd, buff, btread);
        if(bread <= 0)
            break;
        size += bread;

        if(writen(tmpd, buff, bread) != bread) {
            shutdown(sockfd, 2);
            close(sockfd);
            close(acceptd);
            mdprintf(odesc, "Temporary file -> write ERROR\n");
            logg("!ScanStream %d: Can't write to temporary file.\n", port);
            close(tmpd);
            if(!cfgopt(copt, "LeaveTemporaryFiles")->enabled)
                unlink(tmpname);
            free(tmpname);
            return -1;
        }

        if(maxsize && (size + btread >= maxsize)) {
            btread = (maxsize - size); /* only read up to max */

            if(btread <= 0) {
                logg("^ScanStream %d: Size limit reached (max: %d)\n", port, maxsize);
                break; /* Scan what we have */
            }
        }
    }

    switch(retval) {
        case 0: /* timeout */
            mdprintf(odesc, "read timeout ERROR\n");
            logg("!ScanStream %d: read timeout.\n", port);
            break;
        case -1:
            mdprintf(odesc, "read poll ERROR\n");
            logg("!ScanStream %d: read poll failed.\n", port);
            break;
    }

    if(retval == 1) {
        lseek(tmpd, 0, SEEK_SET);
        ret = cl_scandesc(tmpd, &virname, scanned, root, limits, options);
    } else {
        ret = -1;
    }
    close(tmpd);
    if(!cfgopt(copt, "LeaveTemporaryFiles")->enabled)
        unlink(tmpname);
    free(tmpname);

    close(acceptd);
    close(sockfd);

    if(ret == CL_VIRUS) {
        mdprintf(odesc, "stream: %s FOUND\n", virname);
        logg("stream %d: %s FOUND\n", port, virname);
        virusaction("stream", virname, copt);
    } else if(ret != CL_CLEAN) {
        if(retval == 1) {
            mdprintf(odesc, "stream: %s ERROR\n", cl_strerror(ret));
            logg("stream %d: %s ERROR\n", port, cl_strerror(ret));
        }
    } else {
        mdprintf(odesc, "stream: OK\n");
        if(logok)
            logg("stream %d: OK\n", port); 
    }

    return ret;
}

/* submitted by breiter@wolfereiter.com: do not use poll(2) on Interix */
#ifdef C_INTERIX
#undef HAVE_POLL
#undef HAVE_POLL_H
#endif

int poll_fds(int *fds, int nfds, int timeout_sec)
{
        int retval;
        int i;
#ifdef HAVE_POLL
        struct pollfd poll_1[1];
        struct pollfd *poll_data = poll_1;

    if (nfds>1)
        poll_data = malloc(nfds*sizeof(*poll_data));
    for (i=0; i<nfds; i++) {
        poll_data[i].fd = fds[i];
        poll_data[i].events = POLLIN;
        poll_data[i].revents = 0;
    }

    if (timeout_sec > 0) {
        timeout_sec *= 1000;
    }
    while (1) {
        retval = poll(poll_data, nfds, timeout_sec);
        if (retval == -1) {
            if (errno == EINTR) {
                continue;
            }
            if (nfds>1)
                free(poll_data);
            return -1;
        }
        if (nfds>1) {
            if (retval>0) {
                for (i=0; i<nfds; i++) {
                    if (poll_data[i].revents) {
                        retval = i+1;
                        break;
                    }
                }
            }
            free(poll_data);
        }
        return retval;
    }

#else
        fd_set rfds;
        struct timeval tv;
        int maxfd = 0;

    for (i=0; i<nfds; i++) {
        if (fds[i] >= DEFAULT_FD_SETSIZE) {
            return -1;
        }
        if (fds[i] > maxfd)
            maxfd = fds[i];
    }

    while (1) {
        FD_ZERO(&rfds);
        for (i=0; i<nfds; i++)
            FD_SET(fds[i], &rfds);
        tv.tv_sec = timeout_sec;
        tv.tv_usec = 0;

        retval = select(maxfd+1, &rfds, NULL, NULL,
                        (timeout_sec>0 ? &tv : NULL));
        if (retval == -1) {
            if (errno == EINTR) {
                continue;
            }
            return -1;
        }
        if ((nfds>1) && (retval>0)) {
            for (i=0; i<nfds; i++) {
                if (FD_ISSET(fds[i],&rfds)) {
                    retval = i+1;
                    break;
                }
            }
        }
        return retval;
    }
#endif

    return -1;
}

int poll_fd(int fd, int timeout_sec)
{
    return poll_fds(&fd, 1, timeout_sec);
}

        if((cpt = cfgopt(copt, "TCPAddr"))->enabled) {

        pthread_mutex_lock(&gh_mutex);
            if((he = gethostbyname(cpt->strarg)) == 0) {
                logg("!gethostbyname(%s) error: %s\n", cpt->strarg);
                mdprintf(odesc, "gethostbyname(%s) ERROR\n", cpt->strarg);
                pthread_mutex_unlock(&gh_mutex);
                return -1;
            }
            server.sin_addr = *(struct in_addr *) he->h_addr_list[0];
                pthread_mutex_unlock(&gh_mutex);

        } else
            server.sin_addr.s_addr = INADDR_ANY;

        interr = 0;
        char c_buff[36];
        he = gethostbyname_r(cpt->strarg, (struct hostent *)mmalloc(sizeof(struct hostent)), c_buff, sizeof(c_buff), &err);

lwres_gethostbyname_r() is  a
thread-safe  function  for   forward
lookups.  If an error occurs, an error code is returned in
*error.  resbuf is a pointer to a struct hostent which  is
initialised  by  a  successful  call  to  lwres_gethostby-
name_r() .  buf is a buffer of length len bytes  which  is
used  to store the h_name, h_aliases, and h_addr_list ele-
ments of the struct hostent returned in resbuf.   Success-
ful  calls to lwres_gethostbyname_r() return resbuf, which
is a pointer to the struct hostent it created.

    char *c_buff;
    size_t c_buff_len=0;
    int err=0;
    do {
        c_buff_len += 1024;
        c_buff = realloc(c_buff, c_buff_len);
        he = gethostbyname_r(cpt->strarg, he, c_buff, c_buff_len, &err);
    } while (he == NULL && errno == ERANGE);
    if (he == NULL) {
        /* the error handling code */
    }

        if((cpt = cfgopt(copt, "TCPAddr"))->enabled) {
            size_t c_buff_len=0;
                char *c_buff;
                int err=0;
                do {
                        c_buff_len += 1024;
                        c_buff = realloc(c_buff, c_buff_len);
                        he = gethostbyname_r(cpt->strarg, he, c_buff, c_buff_len, &err);
                } while (he == NULL && err == TRY_AGAIN);
    if (he == NULL) {
                logg("!gethostbyname_r(%s) error: %s\n", cpt->strarg);
                mdprintf(odesc, "gethostbyname_r(%s) ERROR\n", cpt->strarg);
                return -1;
    }
                server.sin_addr = *(struct in_addr *) he->h_addr_list[0] ;

        if((cpt = cfgopt(copt, "TCPAddr"))->enabled) {
            pthread_mutex_lock(&gh_mutex);
            if((he = gethostbyname(cpt->strarg)) == 0) {
                logg("!gethostbyname(%s) error: %s\n", cpt->strarg);
                mdprintf(odesc, "gethostbyname(%s) ERROR\n", cpt->strarg);
                pthread_mutex_unlock(&gh_mutex);
                return -1;
            }
            server.sin_addr = *(struct in_addr *) he->h_addr_list[0];
                pthread_mutex_unlock(&gh_mutex);