/*
 *      iovec manipulation routines.
 *
 *
 *              This program is free software; you can redistribute it and/or
 *              modify it under the terms of the GNU General Public License
 *              as published by the Free Software Foundation; either version
 *              2 of the License, or (at your option) any later version.
 *
 *      Fixes:
 *              Andrew Lunn     :       Errors in iovec copying.
 *              Pedro Roque     :       Added memcpy_fromiovecend and
 *                                      csum_..._fromiovecend.
 *              Andi Kleen      :       fixed error handling for 2.1
 *              Alexey Kuznetsov:       2.1 optimisations
 *              Andi Kleen      :       Fix csum*fromiovecend for IPv6.
 */

#include <linux/errno.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/net.h>
#include <linux/in6.h>
#include <asm/uaccess.h>
#include <asm/byteorder.h>
#include <net/checksum.h>
#include <net/sock.h>

/*
 *      Verify iovec. The caller must ensure that the iovec is big enough
 *      to hold the message iovec.
 *
 *      Save time not doing access_ok. copy_*_user will make this work
 *      in any case.
 */

int verify_iovec(struct msghdr *m, struct iovec *iov, struct sockaddr_storage *address, int mode)
{
        int size, ct, err;

        if (m->msg_namelen) {
                if (mode == VERIFY_READ) {
                        void __user *namep;
                        namep = (void __user __force *) m->msg_name;
                        err = move_addr_to_kernel(namep, m->msg_namelen,
                                                  address);
                        if (err < 0)
                                return err;
                }
                if (m->msg_name)
                        m->msg_name = address;
        } else {
                m->msg_name = NULL;
        }

        size = m->msg_iovlen * sizeof(struct iovec);
        if (copy_from_user(iov, (void __user __force *) m->msg_iov, size))
                return -EFAULT;

        m->msg_iov = iov;
        err = 0;

        for (ct = 0; ct < m->msg_iovlen; ct++) {
                size_t len = iov[ct].iov_len;

                if (len > INT_MAX - err) {
                        len = INT_MAX - err;
                        iov[ct].iov_len = len;
                }
                err += len;
        }

        return err;
}

/*
 *      Copy kernel to iovec. Returns -EFAULT on error.
 */

int memcpy_toiovecend(const struct iovec *iov, unsigned char *kdata,
                      int offset, int len)
{
        int copy;
        for (; len > 0; ++iov) {
                /* Skip over the finished iovecs */
                if (unlikely(offset >= iov->iov_len)) {
                        offset -= iov->iov_len;
                        continue;
                }
                copy = min_t(unsigned int, iov->iov_len - offset, len);
                if (copy_to_user(iov->iov_base + offset, kdata, copy))
                        return -EFAULT;
                offset = 0;
                kdata += copy;
                len -= copy;
        }

        return 0;
}
EXPORT_SYMBOL(memcpy_toiovecend);

/*
 *      Copy iovec to kernel. Returns -EFAULT on error.
 */

int memcpy_fromiovecend(unsigned char *kdata, const struct iovec *iov,
                        int offset, int len)
{
        /* Skip over the finished iovecs */
        while (offset >= iov->iov_len) {
                offset -= iov->iov_len;
                iov++;
        }

        while (len > 0) {
                u8 __user *base = iov->iov_base + offset;
                int copy = min_t(unsigned int, len, iov->iov_len - offset);

                offset = 0;
                if (copy_from_user(kdata, base, copy))
                        return -EFAULT;
                len -= copy;
                kdata += copy;
                iov++;
        }

        return 0;
}
EXPORT_SYMBOL(memcpy_fromiovecend);

/*
 *      And now for the all-in-one: copy and checksum from a user iovec
 *      directly to a datagram
 *      Calls to csum_partial but the last must be in 32 bit chunks
 *
 *      ip_build_xmit must ensure that when fragmenting only the last
 *      call to this function will be unaligned also.
 */
int csum_partial_copy_fromiovecend(unsigned char *kdata, struct iovec *iov,
                                 int offset, unsigned int len, __wsum *csump)
{
        __wsum csum = *csump;
        int partial_cnt = 0, err = 0;

        /* Skip over the finished iovecs */
        while (offset >= iov->iov_len) {
                offset -= iov->iov_len;
                iov++;
        }

        while (len > 0) {
                u8 __user *base = iov->iov_base + offset;
                int copy = min_t(unsigned int, len, iov->iov_len - offset);

                offset = 0;

                /* There is a remnant from previous iov. */
                if (partial_cnt) {
                        int par_len = 4 - partial_cnt;

                        /* iov component is too short ... */
                        if (par_len > copy) {
                                if (copy_from_user(kdata, base, copy))
                                        goto out_fault;
                                kdata += copy;
                                base += copy;
                                partial_cnt += copy;
                                len -= copy;
                                iov++;
                                if (len)
                                        continue;
                                *csump = csum_partial(kdata - partial_cnt,
                                                         partial_cnt, csum);
                                goto out;
                        }
                        if (copy_from_user(kdata, base, par_len))
                                goto out_fault;
                        csum = csum_partial(kdata - partial_cnt, 4, csum);
                        kdata += par_len;
                        base  += par_len;
                        copy  -= par_len;
                        len   -= par_len;
                        partial_cnt = 0;
                }

                if (len > copy) {
                        partial_cnt = copy % 4;
                        if (partial_cnt) {
                                copy -= partial_cnt;
                                if (copy_from_user(kdata + copy, base + copy,
                                                partial_cnt))
                                        goto out_fault;
                        }
                }

                if (copy) {
                        csum = csum_and_copy_from_user(base, kdata, copy,
                                                        csum, &err);
                        if (err)
                                goto out;
                }
                len   -= copy + partial_cnt;
                kdata += copy + partial_cnt;
                iov++;
        }
        *csump = csum;
out:
        return err;

out_fault:
        err = -EFAULT;
        goto out;
}
EXPORT_SYMBOL(csum_partial_copy_fromiovecend);

unsigned long iov_pages(const struct iovec *iov, int offset,
                        unsigned long nr_segs)
{
        unsigned long seg, base;
        int pages = 0, len, size;

        while (nr_segs && (offset >= iov->iov_len)) {
                offset -= iov->iov_len;
                ++iov;
                --nr_segs;
        }

        for (seg = 0; seg < nr_segs; seg++) {
                base = (unsigned long)iov[seg].iov_base + offset;
                len = iov[seg].iov_len - offset;
                size = ((base & ~PAGE_MASK) + len + ~PAGE_MASK) >> PAGE_SHIFT;
                pages += size;
                offset = 0;
        }

        return pages;
}
EXPORT_SYMBOL(iov_pages);