APR_DECLARE(apr_status_t) apr_socket_sendtov(apr_socket_t *sock, 

                                             apr_sockaddr_t *where,

                                             apr_int32_t flags,

                                             const struct iovec *vec,

                                             apr_int32_t in_vec,

                                             apr_size_t *nbytes)

{

    apr_status_t rc = APR_SUCCESS;

    apr_ssize_t rv;

    apr_size_t cur_len;

    apr_int32_t nvec = 0;

    int i, j = 0;

    DWORD dwBytes = 0;

    WSABUF *pWsaBuf;

    for (i = 0; i < in_vec; i++) {

        cur_len = vec[i].iov_len;

        nvec++;

        while (cur_len > APR_DWORD_MAX) {

            nvec++;

            cur_len -= APR_DWORD_MAX;

        } 

    }

    pWsaBuf = (nvec <= WSABUF_ON_STACK) ? _alloca(sizeof(WSABUF) * (nvec))

                                         : malloc(sizeof(WSABUF) * (nvec));

    if (!pWsaBuf)

        return APR_ENOMEM;

    for (i = 0; i < in_vec; i++) {

        char * base = vec[i].iov_base;

        cur_len = vec[i].iov_len;

        do {

            if (cur_len > APR_DWORD_MAX) {

                pWsaBuf[j].buf = base;

                pWsaBuf[j].len = APR_DWORD_MAX;

                cur_len -= APR_DWORD_MAX;

                base += APR_DWORD_MAX;

            }

            else {

                pWsaBuf[j].buf = base;

                pWsaBuf[j].len = (DWORD)cur_len;

                cur_len = 0;

            }

            j++;

        } while (cur_len > 0);

    }

    for (i = 0; i < nvec; i++) {

        rv = sendto(sock->socketdes, pWsaBuf[i].buf, pWsaBuf[i].len, flags,

                    (const struct sockaddr*)&where->sa, 

                    where->salen);

        if (rv == SOCKET_ERROR) {

            rc = apr_get_netos_error();

            break;

        }

        dwBytes += rv;

    }

    if (nvec > WSABUF_ON_STACK) 

        free(pWsaBuf);

    *nbytes = dwBytes;

    return rc;

}