1 /* $NetBSD: net_write.c,v 1.3 2023/06/19 21:41:45 christos Exp $ */ 2 3 /* 4 * Copyright (c) 1995, 1996, 1997, 1998 Kungliga Tekniska Högskolan 5 * (Royal Institute of Technology, Stockholm, Sweden). 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * 3. Neither the name of the Institute nor the names of its contributors 20 * may be used to endorse or promote products derived from this software 21 * without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 26 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33 * SUCH DAMAGE. 34 */ 35 36 #include <config.h> 37 38 #include <krb5/roken.h> 39 40 /* 41 * Like write but blocking sockets never return partial data, i.e. we retry on 42 * EINTR. With non-blocking sockets (EWOULDBLOCK or EAGAIN) we return the 43 * number of bytes written. 44 */ 45 46 #ifndef _WIN32 47 48 ROKEN_LIB_FUNCTION ssize_t ROKEN_LIB_CALL 49 net_write (rk_socket_t fd, const void *buf, size_t nbytes) 50 { 51 const char *cbuf = (const char *)buf; 52 ssize_t count; 53 size_t rem = nbytes; 54 55 while (rem > 0) { 56 count = write (fd, cbuf, rem); 57 if (count < 0) { 58 switch (errno) { 59 case EINTR: 60 continue; 61 #if defined(EAGAIN) && EAGAIN != EWOULDBLOCK 62 case EAGAIN: 63 #endif 64 case EWOULDBLOCK: 65 return nbytes - rem; 66 default: 67 return count; 68 } 69 } 70 cbuf += count; 71 rem -= count; 72 } 73 return nbytes; 74 } 75 76 #else 77 78 ROKEN_LIB_FUNCTION ssize_t ROKEN_LIB_CALL 79 net_write(rk_socket_t sock, const void *buf, size_t nbytes) 80 { 81 const char *cbuf = (const char *)buf; 82 ssize_t count; 83 size_t rem = nbytes; 84 #ifdef SOCKET_IS_NOT_AN_FD 85 int use_write = 0; 86 #endif 87 88 while (rem > 0) { 89 #ifdef SOCKET_IS_NOT_AN_FD 90 if (use_write) 91 count = _write (sock, cbuf, rem); 92 else 93 count = send (sock, cbuf, rem, 0); 94 95 if (use_write == 0 && 96 rk_IS_SOCKET_ERROR(count) && 97 (rk_SOCK_ERRNO == WSANOTINITIALISED || 98 rk_SOCK_ERRNO == WSAENOTSOCK)) { 99 use_write = 1; 100 101 count = _write (sock, cbuf, rem); 102 } 103 #else 104 count = send (sock, cbuf, rem, 0); 105 #endif 106 if (count < 0) { 107 if (!use_write) { 108 switch (rk_SOCK_ERRNO) { 109 case WSAEINTR: 110 continue; 111 case WSAEWOULDBLOCK: 112 return nbytes - rem; 113 default: 114 return count; 115 } 116 } else { 117 switch (errno) { 118 case EINTR: 119 continue; 120 case EWOULDBLOCK: 121 return nbytes - rem; 122 default: 123 return count; 124 } 125 } 126 } 127 cbuf += count; 128 rem -= count; 129 } 130 return nbytes; 131 } 132 133 #endif 134