/* ARGSUSED */ int sys_getpeername(struct proc *p, void *v, register_t *retval) { struct sys_getpeername_args /* { syscallarg(int) fdes; syscallarg(struct sockaddr *) asa; syscallarg(socklen_t *) alen; } */ *uap = v; struct file *fp; struct socket *so; struct mbuf *m = NULL; socklen_t len; int error; if ((error = getsock(p->p_fd, SCARG(uap, fdes), &fp)) != 0) return (error); so = fp->f_data; if ((so->so_state & (SS_ISCONNECTED|SS_ISCONFIRMING)) == 0) { FRELE(fp, p); return (ENOTCONN); } error = copyin(SCARG(uap, alen), &len, sizeof (len)); if (error) goto bad; m = m_getclr(M_WAIT, MT_SONAME); error = (*so->so_proto->pr_usrreq)(so, PRU_PEERADDR, 0, m, 0, p); if (error) goto bad; error = copyaddrout(p, m, SCARG(uap, asa), len, SCARG(uap, alen)); bad: FRELE(fp, p); m_freem(m); return (error); }
/* * Get peer socket name. */ int do_sys_getpeername(int fd, struct mbuf **nam) { struct socket *so; struct mbuf *m; int error; if ((error = fd_getsock(fd, &so)) != 0) return error; m = m_getclr(M_WAIT, MT_SONAME); MCLAIM(m, so->so_mowner); solock(so); if ((so->so_state & SS_ISCONNECTED) == 0) error = ENOTCONN; else { *nam = m; error = (*so->so_proto->pr_usrreqs->pr_peeraddr)(so, m); } sounlock(so); if (error != 0) m_free(m); fd_putfile(fd); return error; }
int nfs_boot_sobind_ipport(struct socket *so, uint16_t port, struct lwp *l) { struct mbuf *m; struct sockaddr_in *sin; int error; m = m_getclr(M_WAIT, MT_SONAME); sin = mtod(m, struct sockaddr_in *); sin->sin_len = m->m_len = sizeof(*sin); sin->sin_family = AF_INET; sin->sin_addr.s_addr = INADDR_ANY; sin->sin_port = htons(port); error = sobind(so, m, l); m_freem(m); return (error); }
/* * Copy data from a buffer back into the indicated mbuf chain, * starting "off" bytes from the beginning, extending the mbuf * chain if necessary. The mbuf needs to be properly initialized * including the setting of m_len. */ void m_copyback(struct mbuf *m0, int off, int len, const void *_cp) { int mlen; struct mbuf *m = m0, *n; int totlen = 0; caddr_t cp = (caddr_t)_cp; if (m0 == NULL) return; while (off > (mlen = m->m_len)) { off -= mlen; totlen += mlen; if (m->m_next == NULL) { n = m_getclr(M_DONTWAIT, m->m_type); if (n == NULL) goto out; n->m_len = min(MLEN, len + off); m->m_next = n; } m = m->m_next; } while (len > 0) { mlen = min (m->m_len - off, len); bcopy(cp, off + mtod(m, caddr_t), (unsigned)mlen); cp += mlen; len -= mlen; mlen += off; off = 0; totlen += mlen; if (len == 0) break; if (m->m_next == NULL) { n = m_get(M_DONTWAIT, m->m_type); if (n == NULL) break; n->m_len = min(MLEN, len); m->m_next = n; } m = m->m_next; } out: if (((m = m0)->m_flags & M_PKTHDR) && (m->m_pkthdr.len < totlen)) m->m_pkthdr.len = totlen; }
/* * Get local socket name. */ int do_sys_getsockname(int fd, struct mbuf **nam) { struct socket *so; struct mbuf *m; int error; if ((error = fd_getsock(fd, &so)) != 0) return error; m = m_getclr(M_WAIT, MT_SONAME); MCLAIM(m, so->so_mowner); *nam = m; solock(so); error = (*so->so_proto->pr_usrreqs->pr_sockaddr)(so, m); sounlock(so); if (error != 0) m_free(m); fd_putfile(fd); return error; }
static int getpeersockname (int s, struct sockaddr *name, int *namelen, int pflag) { struct socket *so; struct mbuf *m; int len = *namelen; int error; rtems_bsdnet_semaphore_obtain (); if ((so = rtems_bsdnet_fdToSocket (s)) == NULL) { rtems_bsdnet_semaphore_release (); return -1; } m = m_getclr(M_WAIT, MT_SONAME); if (m == NULL) { errno = ENOBUFS; rtems_bsdnet_semaphore_release (); return -1; } if (pflag) error = (*so->so_proto->pr_usrreqs->pru_peeraddr)(so, m); else error = (*so->so_proto->pr_usrreqs->pru_sockaddr)(so, m); if (error) { m_freem(m); errno = error; rtems_bsdnet_semaphore_release (); return -1; } if (len > m->m_len) { len = m->m_len; *namelen = len; } memcpy (name, mtod(m, caddr_t), len); m_freem (m); rtems_bsdnet_semaphore_release (); return 0; }
static int bsd_getname ( cyg_file *fp, sockaddr *asa, socklen_t *alen, int peer ) { register struct socket *so; struct mbuf *m; socklen_t len = 0; int error; int type = peer ? PRU_PEERADDR : PRU_SOCKADDR; if( alen != NULL ) len = *alen; so = (struct socket *)fp->f_data; if ( peer && (so->so_state & (SS_ISCONNECTED|SS_ISCONFIRMING)) == 0) return (ENOTCONN); m = m_getclr(M_WAIT, MT_SONAME); if (m == NULL) return (ENOBUFS); error = (*so->so_proto->pr_usrreq)(so, type, 0, m, 0); if (error) goto bad; if (len > m->m_len) len = m->m_len; error = copyout(mtod(m, caddr_t), (caddr_t)asa, len); if (error == 0) *alen = len; bad: m_freem(m); return (error); }
int bootpc_call( struct bootp_packet *call, struct bootp_packet *reply, /* output */ struct proc *procp) { struct socket *so; struct sockaddr_in *sin; struct mbuf *m, *nam; struct uio auio; struct iovec aio; int error, rcvflg, timo, secs, len; /* Free at end if not null. */ nam = NULL; /* * Create socket and set its recieve timeout. */ if ((error = socreate(AF_INET, &so, SOCK_DGRAM, 0,procp))) goto out; m = m_get(M_WAIT, MT_SOOPTS); if (m == NULL) { error = ENOBUFS; goto out; } else { struct timeval *tv; tv = mtod(m, struct timeval *); m->m_len = sizeof(*tv); tv->tv_sec = 1; tv->tv_usec = 0; if ((error = sosetopt(so, SOL_SOCKET, SO_RCVTIMEO, m))) goto out; } /* * Enable broadcast. */ { int *on; m = m_get(M_WAIT, MT_SOOPTS); if (m == NULL) { error = ENOBUFS; goto out; } on = mtod(m, int *); m->m_len = sizeof(*on); *on = 1; if ((error = sosetopt(so, SOL_SOCKET, SO_BROADCAST, m))) goto out; } /* * Bind the local endpoint to a bootp client port. */ m = m_getclr(M_WAIT, MT_SONAME); sin = mtod(m, struct sockaddr_in *); sin->sin_len = m->m_len = sizeof(*sin); sin->sin_family = AF_INET; sin->sin_addr.s_addr = INADDR_ANY; sin->sin_port = htons(IPPORT_BOOTPC); error = sobind(so, m); m_freem(m); if (error) { printf("bind failed\n"); goto out; } /* * Setup socket address for the server. */ nam = m_get(M_WAIT, MT_SONAME); if (nam == NULL) { error = ENOBUFS; goto out; } sin = mtod(nam, struct sockaddr_in *); sin-> sin_len = sizeof(*sin); sin-> sin_family = AF_INET; sin->sin_addr.s_addr = INADDR_BROADCAST; sin->sin_port = htons(IPPORT_BOOTPS); nam->m_len = sizeof(*sin); /* * Send it, repeatedly, until a reply is received, * but delay each re-send by an increasing amount. * If the delay hits the maximum, start complaining. */ for (timo=1; timo <= MAX_RESEND_DELAY; timo++) { /* Send BOOTP request (or re-send). */ aio.iov_base = (caddr_t) call; aio.iov_len = sizeof(*call); auio.uio_iov = &aio; auio.uio_iovcnt = 1; auio.uio_segflg = UIO_SYSSPACE; auio.uio_rw = UIO_WRITE; auio.uio_offset = 0; auio.uio_resid = sizeof(*call); auio.uio_procp = procp; error = sosend(so, nam, &auio, NULL, NULL, 0); if (error) { printf("bootpc_call: sosend: %d\n", error); switch (error) { case ENOBUFS: /* No buffer space available */ case ENETUNREACH: /* Network is unreachable */ case ENETDOWN: /* Network interface is not configured */ case EHOSTDOWN: /* Host is down */ case EHOSTUNREACH: /* Host is unreachable */ case EMSGSIZE: /* Message too long */ /* This is a possibly transient error. We can still receive replies from previous attempts. */ break; default: goto out; } } /* * Wait for up to timo seconds for a reply. * The socket receive timeout was set to 1 second. */ secs = timo; while (secs > 0) { aio.iov_base = (caddr_t) reply; aio.iov_len = sizeof(*reply); auio.uio_iov = &aio; auio.uio_iovcnt = 1; auio.uio_segflg = UIO_SYSSPACE; auio.uio_rw = UIO_READ; auio.uio_offset = 0; auio.uio_resid = sizeof(*reply); auio.uio_procp = procp; rcvflg = 0; error = soreceive(so, NULL, &auio, NULL, NULL, &rcvflg); if (error == EWOULDBLOCK) { secs--; call->secs=htons(ntohs(call->secs)+1); continue; } if (error) goto out; len = sizeof(*reply) - auio.uio_resid; /* Do we have the required number of bytes ? */ if (len < BOOTP_MIN_LEN) continue; /* Is it the right reply? */ if (reply->op != 2) continue; if (reply->xid != call->xid) continue; if (reply->hlen != call->hlen) continue; if (bcmp(reply->chaddr,call->chaddr,call->hlen)) continue; goto gotreply; /* break two levels */ } /* while secs */ } /* send/receive a number of times then return an error */ { uint32_t addr = ntohl(sin->sin_addr.s_addr); printf("BOOTP timeout for server %"PRIu32".%"PRIu32".%"PRIu32".%"PRIu32"\n", (addr >> 24) & 0xff, (addr >> 16) & 0xff, (addr >> 8) & 0xff, addr & 0xff); } error = ETIMEDOUT; goto out; gotreply: out: if (nam) m_freem(nam); soclose(so); return error; }
/* * mbuf_copyback differs from m_copyback in a few ways: * 1) mbuf_copyback will allocate clusters for new mbufs we append * 2) mbuf_copyback will grow the last mbuf in the chain if possible * 3) mbuf_copyback reports whether or not the operation succeeded * 4) mbuf_copyback allows the caller to specify M_WAITOK or M_NOWAIT */ errno_t mbuf_copyback( mbuf_t m, size_t off, size_t len, const void *data, mbuf_how_t how) { size_t mlen; mbuf_t m_start = m; mbuf_t n; int totlen = 0; errno_t result = 0; const char *cp = data; if (m == NULL || len == 0 || data == NULL) return (EINVAL); while (off > (mlen = m->m_len)) { off -= mlen; totlen += mlen; if (m->m_next == 0) { n = m_getclr(how, m->m_type); if (n == 0) { result = ENOBUFS; goto out; } n->m_len = MIN(MLEN, len + off); m->m_next = n; } m = m->m_next; } while (len > 0) { mlen = MIN(m->m_len - off, len); if (mlen < len && m->m_next == NULL && mbuf_trailingspace(m) > 0) { size_t grow = MIN(mbuf_trailingspace(m), len - mlen); mlen += grow; m->m_len += grow; } bcopy(cp, off + (char *)mbuf_data(m), (unsigned)mlen); cp += mlen; len -= mlen; mlen += off; off = 0; totlen += mlen; if (len == 0) break; if (m->m_next == 0) { n = m_get(how, m->m_type); if (n == NULL) { result = ENOBUFS; goto out; } if (len > MINCLSIZE) { /* * cluster allocation failure is okay, * we can grow chain */ mbuf_mclget(how, m->m_type, &n); } n->m_len = MIN(mbuf_maxlen(n), len); m->m_next = n; } m = m->m_next; } out: if ((m_start->m_flags & M_PKTHDR) && (m_start->m_pkthdr.len < totlen)) m_start->m_pkthdr.len = totlen; return (result); }