/*      $NetBSD: kttcp.c,v 1.43 2024/07/05 04:31:50 rin Exp $   */

/*
* Copyright (c) 2002 Wasabi Systems, Inc.
* All rights reserved.
*
* Written by Frank van der Linden and Jason R. Thorpe for
* Wasabi Systems, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
*    must display the following acknowledgement:
*      This product includes software developed for the NetBSD Project by
*      Wasabi Systems, Inc.
* 4. The name of Wasabi Systems, Inc. may not be used to endorse
*    or promote products derived from this software without specific prior
*    written permission.
*
* THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL WASABI SYSTEMS, INC
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

/*
* kttcp.c -- provides kernel support for testing network testing,
*            see kttcp(4)
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: kttcp.c,v 1.43 2024/07/05 04:31:50 rin Exp $");

#include <sys/param.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/file.h>
#include <sys/filedesc.h>
#include <sys/conf.h>
#include <sys/systm.h>
#include <sys/protosw.h>
#include <sys/proc.h>
#include <sys/resourcevar.h>
#include <sys/signal.h>
#include <sys/socketvar.h>
#include <sys/socket.h>
#include <sys/mbuf.h>
#include <sys/mount.h>
#include <sys/syscallargs.h>

#include <dev/kttcpio.h>

#include "ioconf.h"

static int kttcp_send(struct lwp *l, struct kttcp_io_args *);
static int kttcp_recv(struct lwp *l, struct kttcp_io_args *);
static int kttcp_sosend(struct socket *, unsigned long long,
                       unsigned long long *, struct lwp *, int);
static int kttcp_soreceive(struct socket *, unsigned long long,
                          unsigned long long *, struct lwp *, int *);

dev_type_ioctl(kttcpioctl);

const struct cdevsw kttcp_cdevsw = {
       .d_open = nullopen,
       .d_close = nullclose,
       .d_read = noread,
       .d_write = nowrite,
       .d_ioctl = kttcpioctl,
       .d_stop = nostop,
       .d_tty = notty,
       .d_poll = nopoll,
       .d_mmap = nommap,
       .d_kqfilter = nokqfilter,
       .d_discard = nodiscard,
       .d_flag = D_OTHER
};

void
kttcpattach(int count)
{
       /* Do nothing. */
}

int
kttcpioctl(dev_t dev, u_long cmd, void *data, int flag,
   struct lwp *l)
{
       int error;

       if ((flag & FWRITE) == 0)
               return EPERM;

       switch (cmd) {
       case KTTCP_IO_SEND:
               error = kttcp_send(l, (struct kttcp_io_args *) data);
               break;

       case KTTCP_IO_RECV:
               error = kttcp_recv(l, (struct kttcp_io_args *) data);
               break;

       default:
               return EINVAL;
       }

       return error;
}

static int
kttcp_send(struct lwp *l, struct kttcp_io_args *kio)
{
       struct socket *so;
       int error;
       struct timeval t0, t1;
       unsigned long long len, done;

       if (kio->kio_totalsize >= KTTCP_MAX_XMIT)
               return EINVAL;

       if ((error = fd_getsock(kio->kio_socket, &so)) != 0)
               return error;

       len = kio->kio_totalsize;
       microtime(&t0);
       do {
               error = kttcp_sosend(so, len, &done, l, 0);
               len -= done;
       } while (error == 0 && len > 0);

       fd_putfile(kio->kio_socket);

       microtime(&t1);
       if (error != 0)
               return error;
       timersub(&t1, &t0, &kio->kio_elapsed);

       kio->kio_bytesdone = kio->kio_totalsize - len;

       return 0;
}

static int
kttcp_recv(struct lwp *l, struct kttcp_io_args *kio)
{
       struct socket *so;
       int error;
       struct timeval t0, t1;
       unsigned long long len, done;

       done = 0;       /* XXX gcc */

       if (kio->kio_totalsize > KTTCP_MAX_XMIT)
               return EINVAL;

       if ((error = fd_getsock(kio->kio_socket, &so)) != 0)
               return error;
       len = kio->kio_totalsize;
       microtime(&t0);
       do {
               error = kttcp_soreceive(so, len, &done, l, NULL);
               len -= done;
       } while (error == 0 && len > 0 && done > 0);

       fd_putfile(kio->kio_socket);

       microtime(&t1);
       if (error == EPIPE)
               error = 0;
       if (error != 0)
               return error;
       timersub(&t1, &t0, &kio->kio_elapsed);

       kio->kio_bytesdone = kio->kio_totalsize - len;

       return 0;
}

#define SBLOCKWAIT(f)   (((f) & MSG_DONTWAIT) ? M_NOWAIT : M_WAITOK)

/*
* Slightly changed version of sosend()
*/
static int
kttcp_sosend(struct socket *so, unsigned long long slen,
            unsigned long long *done, struct lwp *l, int flags)
{
       struct mbuf **mp, *m, *top;
       long space, len, mlen;
       int error, dontroute, atomic;
       long long resid;

       atomic = sosendallatonce(so);
       resid = slen;
       top = NULL;
       /*
        * In theory resid should be unsigned.
        * However, space must be signed, as it might be less than 0
        * if we over-committed, and we must use a signed comparison
        * of space and resid.  On the other hand, a negative resid
        * causes us to loop sending 0-length segments to the protocol.
        */
       if (resid < 0) {
               error = EINVAL;
               goto out;
       }
       dontroute =
           (flags & MSG_DONTROUTE) && (so->so_options & SO_DONTROUTE) == 0 &&
           (so->so_proto->pr_flags & PR_ATOMIC);
       l->l_ru.ru_msgsnd++;
#define snderr(errno)   { error = errno; goto release; }
       solock(so);
restart:
       if ((error = sblock(&so->so_snd, SBLOCKWAIT(flags))) != 0)
               goto out;
       do {
               if (so->so_state & SS_CANTSENDMORE)
                       snderr(EPIPE);
               if (so->so_error) {
                       error = so->so_error;
                       so->so_error = 0;
                       goto release;
               }
               if ((so->so_state & SS_ISCONNECTED) == 0) {
                       if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
                               snderr(ENOTCONN);
                       } else {
                               snderr(EDESTADDRREQ);
                       }
               }
               space = sbspace(&so->so_snd);
               if (flags & MSG_OOB)
                       space += 1024;
               if ((atomic && resid > so->so_snd.sb_hiwat))
                       snderr(EMSGSIZE);
               if (space < resid && (atomic || space < so->so_snd.sb_lowat)) {
                       if (so->so_state & SS_NBIO)
                               snderr(EWOULDBLOCK);
                       SBLASTRECORDCHK(&so->so_rcv,
                           "kttcp_soreceive sbwait 1");
                       SBLASTMBUFCHK(&so->so_rcv,
                           "kttcp_soreceive sbwait 1");
                       sbunlock(&so->so_snd);
                       error = sbwait(&so->so_snd);
                       if (error)
                               goto out;
                       goto restart;
               }
               mp = &top;
               do {
                       sounlock(so);
                       do {
                               if (top == 0) {
                                       m = m_gethdr(M_WAIT, MT_DATA);
                                       mlen = MHLEN;
                                       m->m_pkthdr.len = 0;
                                       m_reset_rcvif(m);
                               } else {
                                       m = m_get(M_WAIT, MT_DATA);
                                       mlen = MLEN;
                               }
                               if (resid >= MINCLSIZE && space >= MCLBYTES) {
                                       m_clget(m, M_WAIT);
                                       if ((m->m_flags & M_EXT) == 0)
                                               goto nopages;
                                       mlen = MCLBYTES;
#ifdef  MAPPED_MBUFS
                                       len = lmin(MCLBYTES, resid);
#else
                                       if (atomic && top == 0) {
                                               len = lmin(MCLBYTES - max_hdr,
                                                   resid);
                                               m->m_data += max_hdr;
                                       } else
                                               len = lmin(MCLBYTES, resid);
#endif
                                       space -= len;
                               } else {
nopages:
                                       len = lmin(lmin(mlen, resid), space);
                                       space -= len;
                                       /*
                                        * For datagram protocols, leave room
                                        * for protocol headers in first mbuf.
                                        */
                                       if (atomic && top == 0 && len < mlen)
                                               m_align(m, len);
                               }
                               resid -= len;
                               m->m_len = len;
                               *mp = m;
                               top->m_pkthdr.len += len;
                               if (error)
                                       goto release;
                               mp = &m->m_next;
                               if (resid <= 0) {
                                       if (flags & MSG_EOR)
                                               top->m_flags |= M_EOR;
                                       break;
                               }
                       } while (space > 0 && atomic);
                       solock(so);

                       if (so->so_state & SS_CANTSENDMORE)
                               snderr(EPIPE);
                       if (dontroute)
                               so->so_options |= SO_DONTROUTE;
                       if (resid > 0)
                               so->so_state |= SS_MORETOCOME;
                       if (flags & MSG_OOB)
                               error = (*so->so_proto->pr_usrreqs->pr_sendoob)(so,
                                   top, NULL);
                       else
                               error = (*so->so_proto->pr_usrreqs->pr_send)(so,
                                   top, NULL, NULL, l);
                       if (dontroute)
                               so->so_options &= ~SO_DONTROUTE;
                       if (resid > 0)
                               so->so_state &= ~SS_MORETOCOME;
                       top = 0;
                       mp = &top;
                       if (error)
                               goto release;
               } while (resid && space > 0);
       } while (resid);

release:
       sbunlock(&so->so_snd);
out:
       sounlock(so);
       m_freem(top);
       *done = slen - resid;
#if 0
       printf("sosend: error %d slen %llu resid %lld\n", error, slen, resid);
#endif
       return (error);
}

static int
kttcp_soreceive(struct socket *so, unsigned long long slen,
   unsigned long long *done, struct lwp *l, int *flagsp)
{
       struct mbuf *m, **mp;
       int flags, len, error, offset, moff, type;
       long long orig_resid, resid;
       const struct protosw *pr;
       struct mbuf *nextrecord;

       pr = so->so_proto;
       mp = NULL;
       type = 0;
       resid = orig_resid = slen;
       if (flagsp)
               flags = *flagsp &~ MSG_EOR;
       else
               flags = 0;
       if (flags & MSG_OOB) {
               m = m_get(M_WAIT, MT_DATA);
               solock(so);
               error = (*pr->pr_usrreqs->pr_recvoob)(so, m, flags & MSG_PEEK);
               sounlock(so);
               if (error)
                       goto bad;
               do {
                       resid -= uimin(resid, m->m_len);
                       m = m_free(m);
               } while (resid && error == 0 && m);
bad:
               m_freem(m);
               return (error);
       }
       if (mp)
               *mp = NULL;
       solock(so);
restart:
       if ((error = sblock(&so->so_rcv, SBLOCKWAIT(flags))) != 0)
               return (error);
       m = so->so_rcv.sb_mb;
       /*
        * If we have less data than requested, block awaiting more
        * (subject to any timeout) if:
        *   1. the current count is less than the low water mark,
        *   2. MSG_WAITALL is set, and it is possible to do the entire
        *      receive operation at once if we block (resid <= hiwat), or
        *   3. MSG_DONTWAIT is not set.
        * If MSG_WAITALL is set but resid is larger than the receive buffer,
        * we have to do the receive in sections, and thus risk returning
        * a short count if a timeout or signal occurs after we start.
        */
       if (m == NULL || (((flags & MSG_DONTWAIT) == 0 &&
           so->so_rcv.sb_cc < resid) &&
           (so->so_rcv.sb_cc < so->so_rcv.sb_lowat ||
           ((flags & MSG_WAITALL) && resid <= so->so_rcv.sb_hiwat)) &&
           m->m_nextpkt == NULL && (pr->pr_flags & PR_ATOMIC) == 0)) {
#ifdef DIAGNOSTIC
               if (m == NULL && so->so_rcv.sb_cc)
                       panic("receive 1");
#endif
               if (so->so_error) {
                       if (m)
                               goto dontblock;
                       error = so->so_error;
                       if ((flags & MSG_PEEK) == 0)
                               so->so_error = 0;
                       goto release;
               }
               if (so->so_state & SS_CANTRCVMORE) {
                       if (m)
                               goto dontblock;
                       else
                               goto release;
               }
               for (; m; m = m->m_next)
                       if (m->m_type == MT_OOBDATA  || (m->m_flags & M_EOR)) {
                               m = so->so_rcv.sb_mb;
                               goto dontblock;
                       }
               if ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) == 0 &&
                   (so->so_proto->pr_flags & PR_CONNREQUIRED)) {
                       error = ENOTCONN;
                       goto release;
               }
               if (resid == 0)
                       goto release;
               if ((so->so_state & SS_NBIO) ||
                   (flags & (MSG_DONTWAIT|MSG_NBIO))) {
                       error = EWOULDBLOCK;
                       goto release;
               }
               sbunlock(&so->so_rcv);
               error = sbwait(&so->so_rcv);
               if (error) {
                       sounlock(so);
                       return (error);
               }
               goto restart;
       }
dontblock:
       /*
        * On entry here, m points to the first record of the socket buffer.
        * While we process the initial mbufs containing address and control
        * info, we save a copy of m->m_nextpkt into nextrecord.
        */
#ifdef notyet /* XXXX */
       if (uio->uio_lwp)
               uio->uio_lwp->l_ru.ru_msgrcv++;
#endif
       KASSERT(m == so->so_rcv.sb_mb);
       SBLASTRECORDCHK(&so->so_rcv, "kttcp_soreceive 1");
       SBLASTMBUFCHK(&so->so_rcv, "kttcp_soreceive 1");
       nextrecord = m->m_nextpkt;
       if (pr->pr_flags & PR_ADDR) {
#ifdef DIAGNOSTIC
               if (m->m_type != MT_SONAME)
                       panic("receive 1a");
#endif
               orig_resid = 0;
               if (flags & MSG_PEEK) {
                       m = m->m_next;
               } else {
                       sbfree(&so->so_rcv, m);
                       m = so->so_rcv.sb_mb = m_free(m);
               }
       }
       while (m && m->m_type == MT_CONTROL && error == 0) {
               if (flags & MSG_PEEK) {
                       m = m->m_next;
               } else {
                       sbfree(&so->so_rcv, m);
                       m = so->so_rcv.sb_mb = m_free(m);
               }
       }

       /*
        * If m is non-NULL, we have some data to read.  From now on,
        * make sure to keep sb_lastrecord consistent when working on
        * the last packet on the chain (nextrecord == NULL) and we
        * change m->m_nextpkt.
        */
       if (m) {
               if ((flags & MSG_PEEK) == 0) {
                       m->m_nextpkt = nextrecord;
                       /*
                        * If nextrecord == NULL (this is a single chain),
                        * then sb_lastrecord may not be valid here if m
                        * was changed earlier.
                        */
                       if (nextrecord == NULL) {
                               KASSERT(so->so_rcv.sb_mb == m);
                               so->so_rcv.sb_lastrecord = m;
                       }
               }
               type = m->m_type;
               if (type == MT_OOBDATA)
                       flags |= MSG_OOB;
       } else {
               if ((flags & MSG_PEEK) == 0) {
                       KASSERT(so->so_rcv.sb_mb == m);
                       so->so_rcv.sb_mb = nextrecord;
                       SB_EMPTY_FIXUP(&so->so_rcv);
               }
       }
       SBLASTRECORDCHK(&so->so_rcv, "kttcp_soreceive 2");
       SBLASTMBUFCHK(&so->so_rcv, "kttcp_soreceive 2");

       moff = 0;
       offset = 0;
       while (m && resid > 0 && error == 0) {
               if (m->m_type == MT_OOBDATA) {
                       if (type != MT_OOBDATA)
                               break;
               } else if (type == MT_OOBDATA)
                       break;
#ifdef DIAGNOSTIC
               else if (m->m_type != MT_DATA && m->m_type != MT_HEADER)
                       panic("receive 3");
#endif
               so->so_state &= ~SS_RCVATMARK;
               len = resid;
               if (so->so_oobmark && len > so->so_oobmark - offset)
                       len = so->so_oobmark - offset;
               if (len > m->m_len - moff)
                       len = m->m_len - moff;
               /*
                * If mp is set, just pass back the mbufs.
                * Otherwise copy them out via the uio, then free.
                * Sockbuf must be consistent here (points to current mbuf,
                * it points to next record) when we drop priority;
                * we must note any additions to the sockbuf when we
                * block interrupts again.
                */
               resid -= len;
               if (len == m->m_len - moff) {
                       if (m->m_flags & M_EOR)
                               flags |= MSG_EOR;
                       if (flags & MSG_PEEK) {
                               m = m->m_next;
                               moff = 0;
                       } else {
                               nextrecord = m->m_nextpkt;
                               sbfree(&so->so_rcv, m);
                               if (mp) {
                                       *mp = m;
                                       mp = &m->m_next;
                                       so->so_rcv.sb_mb = m = m->m_next;
                                       *mp = NULL;
                               } else {
                                       m = so->so_rcv.sb_mb = m_free(m);
                               }
                               /*
                                * If m != NULL, we also know that
                                * so->so_rcv.sb_mb != NULL.
                                */
                               KASSERT(so->so_rcv.sb_mb == m);
                               if (m) {
                                       m->m_nextpkt = nextrecord;
                                       if (nextrecord == NULL)
                                               so->so_rcv.sb_lastrecord = m;
                               } else {
                                       so->so_rcv.sb_mb = nextrecord;
                                       SB_EMPTY_FIXUP(&so->so_rcv);
                               }
                               SBLASTRECORDCHK(&so->so_rcv,
                                   "kttcp_soreceive 3");
                               SBLASTMBUFCHK(&so->so_rcv,
                                   "kttcp_soreceive 3");
                       }
               } else {
                       if (flags & MSG_PEEK)
                               moff += len;
                       else {
                               if (mp) {
                                       sounlock(so);
                                       *mp = m_copym(m, 0, len, M_WAIT);
                                       solock(so);
                               }
                               m->m_data += len;
                               m->m_len -= len;
                               so->so_rcv.sb_cc -= len;
                       }
               }
               if (so->so_oobmark) {
                       if ((flags & MSG_PEEK) == 0) {
                               so->so_oobmark -= len;
                               if (so->so_oobmark == 0) {
                                       so->so_state |= SS_RCVATMARK;
                                       break;
                               }
                       } else {
                               offset += len;
                               if (offset == so->so_oobmark)
                                       break;
                       }
               }
               if (flags & MSG_EOR)
                       break;
               /*
                * If the MSG_WAITALL flag is set (for non-atomic socket),
                * we must not quit until "uio->uio_resid == 0" or an error
                * termination.  If a signal/timeout occurs, return
                * with a short count but without error.
                * Keep sockbuf locked against other readers.
                */
               while (flags & MSG_WAITALL && m == NULL && resid > 0 &&
                   !sosendallatonce(so) && !nextrecord) {
                       if (so->so_error || so->so_state & SS_CANTRCVMORE)
                               break;
                       /*
                        * If we are peeking and the socket receive buffer is
                        * full, stop since we can't get more data to peek at.
                        */
                       if ((flags & MSG_PEEK) && sbspace(&so->so_rcv) <= 0)
                               break;
                       /*
                        * If we've drained the socket buffer, tell the
                        * protocol in case it needs to do something to
                        * get it filled again.
                        */
                       if ((pr->pr_flags & PR_WANTRCVD) && so->so_pcb) {
                               (*pr->pr_usrreqs->pr_rcvd)(so, flags, l);
                       }
                       SBLASTRECORDCHK(&so->so_rcv,
                           "kttcp_soreceive sbwait 2");
                       SBLASTMBUFCHK(&so->so_rcv,
                           "kttcp_soreceive sbwait 2");
                       error = sbwait(&so->so_rcv);
                       if (error) {
                               sbunlock(&so->so_rcv);
                               sounlock(so);
                               return (0);
                       }
                       if ((m = so->so_rcv.sb_mb) != NULL)
                               nextrecord = m->m_nextpkt;
               }
       }

       if (m && pr->pr_flags & PR_ATOMIC) {
               flags |= MSG_TRUNC;
               if ((flags & MSG_PEEK) == 0)
                       (void) sbdroprecord(&so->so_rcv);
       }
       if ((flags & MSG_PEEK) == 0) {
               if (m == NULL) {
                       /*
                        * First part is an SB_EMPTY_FIXUP().  Second part
                        * makes sure sb_lastrecord is up-to-date if
                        * there is still data in the socket buffer.
                        */
                       so->so_rcv.sb_mb = nextrecord;
                       if (so->so_rcv.sb_mb == NULL) {
                               so->so_rcv.sb_mbtail = NULL;
                               so->so_rcv.sb_lastrecord = NULL;
                       } else if (nextrecord->m_nextpkt == NULL)
                               so->so_rcv.sb_lastrecord = nextrecord;
               }
               SBLASTRECORDCHK(&so->so_rcv, "kttcp_soreceive 4");
               SBLASTMBUFCHK(&so->so_rcv, "kttcp_soreceive 4");
               if (pr->pr_flags & PR_WANTRCVD && so->so_pcb) {
                       (*pr->pr_usrreqs->pr_rcvd)(so, flags, l);
               }
       }
       if (orig_resid == resid && orig_resid &&
           (flags & MSG_EOR) == 0 && (so->so_state & SS_CANTRCVMORE) == 0) {
               sbunlock(&so->so_rcv);
               goto restart;
       }

       if (flagsp)
               *flagsp |= flags;
release:
       sbunlock(&so->so_rcv);
       sounlock(so);
       *done = slen - resid;
#if 0
       printf("soreceive: error %d slen %llu resid %lld\n", error, slen, resid);
#endif
       return (error);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.