Revision ce053661 net.c

b/net.c
36 36
#include "qemu-common.h"
37 37
#include "qemu_socket.h"
38 38
#include "hw/qdev.h"
39
#include "iov.h"
39 40

  
40 41
static QTAILQ_HEAD(, VLANState) vlans;
41 42
static QTAILQ_HEAD(, VLANClientState) non_vlan_clients;
......
572 573
                               int iovcnt)
573 574
{
574 575
    uint8_t buffer[4096];
575
    size_t offset = 0;
576
    int i;
577

  
578
    for (i = 0; i < iovcnt; i++) {
579
        size_t len;
576
    size_t offset;
580 577

  
581
        len = MIN(sizeof(buffer) - offset, iov[i].iov_len);
582
        memcpy(buffer + offset, iov[i].iov_base, len);
583
        offset += len;
584
    }
578
    offset = iov_to_buf(iov, iovcnt, buffer, 0, sizeof(buffer));
585 579

  
586 580
    return vc->info->receive(vc, buffer, offset);
587 581
}
588 582

  
589
static ssize_t calc_iov_length(const struct iovec *iov, int iovcnt)
590
{
591
    size_t offset = 0;
592
    int i;
593

  
594
    for (i = 0; i < iovcnt; i++)
595
        offset += iov[i].iov_len;
596
    return offset;
597
}
598

  
599 583
static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
600 584
                                       unsigned flags,
601 585
                                       const struct iovec *iov,
......
605 589
    VLANClientState *vc = opaque;
606 590

  
607 591
    if (vc->link_down) {
608
        return calc_iov_length(iov, iovcnt);
592
        return iov_size(iov, iovcnt);
609 593
    }
610 594

  
611 595
    if (vc->info->receive_iov) {
......
633 617
        }
634 618

  
635 619
        if (vc->link_down) {
636
            ret = calc_iov_length(iov, iovcnt);
620
            ret = iov_size(iov, iovcnt);
637 621
            continue;
638 622
        }
639 623

  
......
658 642
    NetQueue *queue;
659 643

  
660 644
    if (sender->link_down || (!sender->peer && !sender->vlan)) {
661
        return calc_iov_length(iov, iovcnt);
645
        return iov_size(iov, iovcnt);
662 646
    }
663 647

  
664 648
    if (sender->peer) {

Also available in: Unified diff