[babeltrace.git] / src / compat / socket.h

#ifndef _BABELTRACE_COMPAT_SOCKET_H
#define _BABELTRACE_COMPAT_SOCKET_H

/*
 * Copyright (C) 2015-2017  Michael Jeanson <mjeanson@efficios.com>
 *               2015  Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <stdbool.h>

#ifdef __MINGW32__

#include <winsock2.h>

#define BT_INVALID_SOCKET INVALID_SOCKET
#define BT_SOCKET_ERROR SOCKET_ERROR
#define BT_SOCKET SOCKET

static inline
int bt_socket_init(int log_level)
{
	WORD verreq;
	WSADATA wsa;
	int ret;

	/* Request winsock 2.2 support */
	verreq = MAKEWORD(2, 2);

	ret = WSAStartup(verreq, &wsa);
	if (ret != 0) {
#ifdef BT_LOG_WRITE_CUR_LVL
		BT_LOG_WRITE_CUR_LVL(BT_LOG_ERROR, log_level, BT_LOG_TAG,
				"Winsock init failed with error: %d", ret);
#endif
		goto end;
	}

	if (LOBYTE(wsa.wVersion) != 2 || HIBYTE(wsa.wVersion) != 2) {
#ifdef BT_LOG_WRITE_CUR_LVL
		BT_LOG_WRITE_CUR_LVL(BT_LOG_ERROR, log_level, BT_LOG_TAG,
				"Could not init winsock 2.2 support");
#endif
		WSACleanup();
		ret = -1;
	}

end:
	return ret;
}

static inline
int bt_socket_fini(void)
{
	return WSACleanup();
}

static inline
int bt_socket_send(int sockfd, const void *buf, size_t len, int flags)
{
	return send(sockfd, buf, len, flags);
}

static inline
int bt_socket_recv(int sockfd, void *buf, size_t len, int flags)
{
	return recv(sockfd, buf, len, flags);
}

static inline
int bt_socket_close(int fd)
{
	return closesocket(fd);
}

static inline
bool bt_socket_interrupted(void)
{
	/* There is no equivalent to EINTR in winsock 2.2 */
	return false;
}

static inline
const char *bt_socket_errormsg(void)
{
	const char *errstr;
	int error = WSAGetLastError();

	switch (error) {
	case WSAEINTR:
		errstr = "Call interrupted";
		break;
	case WSAEBADF:
		errstr = "Bad file";
		break;
	case WSAEACCES:
		errstr = "Bad access";
		break;
	case WSAEFAULT:
		errstr = "Bad argument";
		break;
	case WSAEINVAL:
		errstr = "Invalid arguments";
		break;
	case WSAEMFILE:
		errstr = "Out of file descriptors";
		break;
	case WSAEWOULDBLOCK:
		errstr = "Call would block";
		break;
	case WSAEINPROGRESS:
	case WSAEALREADY:
		errstr = "Blocking call in progress";
		break;
	case WSAENOTSOCK:
		errstr = "Descriptor is not a socket";
		break;
	case WSAEDESTADDRREQ:
		errstr = "Need destination address";
		break;
	case WSAEMSGSIZE:
		errstr = "Bad message size";
		break;
	case WSAEPROTOTYPE:
		errstr = "Bad protocol";
		break;
	case WSAENOPROTOOPT:
		errstr = "Protocol option is unsupported";
		break;
	case WSAEPROTONOSUPPORT:
		errstr = "Protocol is unsupported";
		break;
	case WSAESOCKTNOSUPPORT:
		errstr = "Socket is unsupported";
		break;
	case WSAEOPNOTSUPP:
		errstr = "Operation not supported";
		break;
	case WSAEAFNOSUPPORT:
		errstr = "Address family not supported";
		break;
	case WSAEPFNOSUPPORT:
		errstr = "Protocol family not supported";
		break;
	case WSAEADDRINUSE:
		errstr = "Address already in use";
		break;
	case WSAEADDRNOTAVAIL:
		errstr = "Address not available";
		break;
	case WSAENETDOWN:
		errstr = "Network down";
		break;
	case WSAENETUNREACH:
		errstr = "Network unreachable";
		break;
	case WSAENETRESET:
		errstr = "Network has been reset";
		break;
	case WSAECONNABORTED:
		errstr = "Connection was aborted";
		break;
	case WSAECONNRESET:
		errstr = "Connection was reset";
		break;
	case WSAENOBUFS:
		errstr = "No buffer space";
		break;
	case WSAEISCONN:
		errstr = "Socket is already connected";
		break;
	case WSAENOTCONN:
		errstr = "Socket is not connected";
		break;
	case WSAESHUTDOWN:
		errstr = "Socket has been shut down";
		break;
	case WSAETOOMANYREFS:
		errstr = "Too many references";
		break;
	case WSAETIMEDOUT:
		errstr = "Timed out";
		break;
	case WSAECONNREFUSED:
		errstr = "Connection refused";
		break;
	case WSAELOOP:
		errstr = "Loop??";
		break;
	case WSAENAMETOOLONG:
		errstr = "Name too long";
		break;
	case WSAEHOSTDOWN:
		errstr = "Host down";
		break;
	case WSAEHOSTUNREACH:
		errstr = "Host unreachable";
		break;
	case WSAENOTEMPTY:
		errstr = "Not empty";
		break;
	case WSAEPROCLIM:
		errstr = "Process limit reached";
		break;
	case WSAEUSERS:
		errstr = "Too many users";
		break;
	case WSAEDQUOT:
		errstr = "Bad quota";
		break;
	case WSAESTALE:
		errstr = "Something is stale";
		break;
	case WSAEREMOTE:
		errstr = "Remote error";
		break;
	case WSAEDISCON:
		errstr = "Disconnected";
		break;

	/* Extended Winsock errors */
	case WSASYSNOTREADY:
		errstr = "Winsock library is not ready";
		break;
	case WSANOTINITIALISED:
		errstr = "Winsock library not initialised";
		break;
	case WSAVERNOTSUPPORTED:
		errstr = "Winsock version not supported";
		break;

	/* getXbyY() errors (already handled in herrmsg):
	 * Authoritative Answer: Host not found */
	case WSAHOST_NOT_FOUND:
		errstr = "Host not found";
		break;

	/* Non-Authoritative: Host not found, or SERVERFAIL */
	case WSATRY_AGAIN:
		errstr = "Host not found, try again";
		break;

	/* Non recoverable errors, FORMERR, REFUSED, NOTIMP */
	case WSANO_RECOVERY:
		errstr = "Unrecoverable error in call to nameserver";
		break;

	/* Valid name, no data record of requested type */
	case WSANO_DATA:
		errstr = "No data record of requested type";
		break;

	default:
		errstr = "Unknown error";
	}

	return errstr;
}

#else /* __MINGW32__ */

#include <errno.h>
#include <netdb.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <unistd.h>

#include <glib.h>

#define BT_INVALID_SOCKET -1
#define BT_SOCKET_ERROR -1
#define BT_SOCKET int

static inline
int bt_socket_init(int log_level)
{
	return 0;
}

static inline
int bt_socket_fini(void)
{
	return 0;
}

static inline
int bt_socket_send(int sockfd, const void *buf, size_t len, int flags)
{
	return send(sockfd, buf, len, flags);
}

static inline
int bt_socket_recv(int sockfd, void *buf, size_t len, int flags)
{
	return recv(sockfd, buf, len, flags);
}

static inline
int bt_socket_close(int fd)
{
	return close(fd);
}

static inline
bool bt_socket_interrupted(void)
{
	return (errno == EINTR);
}

static inline
const char *bt_socket_errormsg(void)
{
	return g_strerror(errno);
}
#endif


/*
 * This wrapper is used on platforms that have no way of ignoring SIGPIPE
 * during a send().
 */

#ifndef MSG_NOSIGNAL
# ifdef SO_NOSIGPIPE
#   define MSG_NOSIGNAL SO_NOSIGPIPE
# elif defined(__MINGW32__)
#   define MSG_NOSIGNAL 0
# endif
#endif

#if defined(MSG_NOSIGNAL)
static inline
ssize_t bt_socket_send_nosigpipe(int fd, const void *buffer, size_t size)
{
	return bt_socket_send(fd, buffer, size, MSG_NOSIGNAL);
}
#else

#include <signal.h>

static inline
ssize_t bt_socket_send_nosigpipe(int fd, const void *buffer, size_t size)
{
	ssize_t sent;
	int saved_err;
	sigset_t sigpipe_set, pending_set, old_set;
	int sigpipe_was_pending;

	/*
	 * Discard the SIGPIPE from send(), not disturbing any SIGPIPE
	 * that might be already pending. If a bogus SIGPIPE is sent to
	 * the entire process concurrently by a malicious user, it may
	 * be simply discarded.
	 */
	if (sigemptyset(&pending_set)) {
		return -1;
	}
	/*
	 * sigpending returns the mask of signals that are _both_
	 * blocked for the thread _and_ pending for either the thread or
	 * the entire process.
	 */
	if (sigpending(&pending_set)) {
		return -1;
	}
	sigpipe_was_pending = sigismember(&pending_set, SIGPIPE);
	/*
	 * If sigpipe was pending, it means it was already blocked, so
	 * no need to block it.
	 */
	if (!sigpipe_was_pending) {
		if (sigemptyset(&sigpipe_set)) {
			return -1;
		}
		if (sigaddset(&sigpipe_set, SIGPIPE)) {
			return -1;
		}
		if (pthread_sigmask(SIG_BLOCK, &sigpipe_set, &old_set)) {
			return -1;
		}
	}

	/* Send and save errno. */
	sent = bt_socket_send(fd, buffer, size, 0);
	saved_err = errno;

	if (sent == -1 && errno == EPIPE && !sigpipe_was_pending) {
		struct timespec timeout = { 0, 0 };
		int ret;

		do {
			ret = sigtimedwait(&sigpipe_set, NULL,
				&timeout);
		} while (ret == -1 && errno == EINTR);
	}
	if (!sigpipe_was_pending) {
		if (pthread_sigmask(SIG_SETMASK, &old_set, NULL)) {
			return -1;
		}
	}
	/* Restore send() errno */
	errno = saved_err;

	return sent;
}
#endif


#endif /* _BABELTRACE_COMPAT_SOCKET_H */
Commit	Line	Data
1cb3cdd7 MJ	1	#ifndef _BABELTRACE_COMPAT_SOCKET_H
	2	#define _BABELTRACE_COMPAT_SOCKET_H
	3
	4	/*
1cb3cdd7 MJ	5	* Copyright (C) 2015-2017 Michael Jeanson <mjeanson@efficios.com>
	6	* 2015 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	7	*
	8	* Permission is hereby granted, free of charge, to any person obtaining a copy
	9	* of this software and associated documentation files (the "Software"), to deal
	10	* in the Software without restriction, including without limitation the rights
	11	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	12	* copies of the Software, and to permit persons to whom the Software is
	13	* furnished to do so, subject to the following conditions:
	14	*
	15	* The above copyright notice and this permission notice shall be included in
	16	* all copies or substantial portions of the Software.
	17	*
	18	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	19	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	20	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	21	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	22	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	23	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	24	* SOFTWARE.
	25	*/
	26
c4f23e30 FD	27	#include <stdbool.h>
c4f23e30 FD	28
1cb3cdd7 MJ	29	#ifdef __MINGW32__
	30
	31	#include <winsock2.h>
	32
	33	#define BT_INVALID_SOCKET INVALID_SOCKET
	34	#define BT_SOCKET_ERROR SOCKET_ERROR
	35	#define BT_SOCKET SOCKET
	36
	37	static inline
95c324a4	38	int bt_socket_init(int log_level)
1cb3cdd7 MJ	39	{
	40	WORD verreq;
	41	WSADATA wsa;
	42	int ret;
	43
	44	/* Request winsock 2.2 support */
	45	verreq = MAKEWORD(2, 2);
	46
	47	ret = WSAStartup(verreq, &wsa);
	48	if (ret != 0) {
95c324a4 JR	49	#ifdef BT_LOG_WRITE_CUR_LVL
	50	BT_LOG_WRITE_CUR_LVL(BT_LOG_ERROR, log_level, BT_LOG_TAG,
	51	"Winsock init failed with error: %d", ret);
f571b963	52	#endif
1cb3cdd7 MJ	53	goto end;
	54	}
	55
	56	if (LOBYTE(wsa.wVersion) != 2 \|\| HIBYTE(wsa.wVersion) != 2) {
95c324a4 JR	57	#ifdef BT_LOG_WRITE_CUR_LVL
	58	BT_LOG_WRITE_CUR_LVL(BT_LOG_ERROR, log_level, BT_LOG_TAG,
	59	"Could not init winsock 2.2 support");
f571b963	60	#endif
1cb3cdd7 MJ	61	WSACleanup();
	62	ret = -1;
	63	}
	64
	65	end:
	66	return ret;
	67	}
	68
	69	static inline
	70	int bt_socket_fini(void)
	71	{
	72	return WSACleanup();
	73	}
	74
	75	static inline
	76	int bt_socket_send(int sockfd, const void *buf, size_t len, int flags)
	77	{
	78	return send(sockfd, buf, len, flags);
	79	}
	80
	81	static inline
	82	int bt_socket_recv(int sockfd, void *buf, size_t len, int flags)
	83	{
	84	return recv(sockfd, buf, len, flags);
	85	}
	86
	87	static inline
	88	int bt_socket_close(int fd)
	89	{
	90	return closesocket(fd);
	91	}
	92
	93	static inline
	94	bool bt_socket_interrupted(void)
	95	{
	96	/* There is no equivalent to EINTR in winsock 2.2 */
	97	return false;
	98	}
	99
	100	static inline
	101	const char *bt_socket_errormsg(void)
	102	{
	103	const char *errstr;
	104	int error = WSAGetLastError();
	105
	106	switch (error) {
	107	case WSAEINTR:
	108	errstr = "Call interrupted";
	109	break;
	110	case WSAEBADF:
	111	errstr = "Bad file";
	112	break;
	113	case WSAEACCES:
	114	errstr = "Bad access";
	115	break;
	116	case WSAEFAULT:
	117	errstr = "Bad argument";
	118	break;
	119	case WSAEINVAL:
	120	errstr = "Invalid arguments";
	121	break;
	122	case WSAEMFILE:
	123	errstr = "Out of file descriptors";
	124	break;
125	case WSAEWOULDBLOCK:
126	errstr = "Call would block";
127	break;
128	case WSAEINPROGRESS:
129	case WSAEALREADY:
130	errstr = "Blocking call in progress";
131	break;
132	case WSAENOTSOCK:
133	errstr = "Descriptor is not a socket";
134	break;
135	case WSAEDESTADDRREQ:
136	errstr = "Need destination address";
137	break;
138	case WSAEMSGSIZE:
139	errstr = "Bad message size";
140	break;
141	case WSAEPROTOTYPE:
142	errstr = "Bad protocol";
143	break;
144	case WSAENOPROTOOPT:
145	errstr = "Protocol option is unsupported";
146	break;
147	case WSAEPROTONOSUPPORT:
148	errstr = "Protocol is unsupported";
149	break;
150	case WSAESOCKTNOSUPPORT:
151	errstr = "Socket is unsupported";
152	break;
153	case WSAEOPNOTSUPP:
154	errstr = "Operation not supported";
155	break;
156	case WSAEAFNOSUPPORT:
157	errstr = "Address family not supported";
158	break;
159	case WSAEPFNOSUPPORT:
160	errstr = "Protocol family not supported";
161	break;
162	case WSAEADDRINUSE:
163	errstr = "Address already in use";
164	break;
165	case WSAEADDRNOTAVAIL:
166	errstr = "Address not available";
167	break;
168	case WSAENETDOWN:
169	errstr = "Network down";
170	break;
171	case WSAENETUNREACH:
172	errstr = "Network unreachable";
173	break;
174	case WSAENETRESET:
175	errstr = "Network has been reset";
176	break;
177	case WSAECONNABORTED:
178	errstr = "Connection was aborted";
179	break;
180	case WSAECONNRESET:
181	errstr = "Connection was reset";
182	break;
183	case WSAENOBUFS:
184	errstr = "No buffer space";
185	break;
186	case WSAEISCONN:
187	errstr = "Socket is already connected";
188	break;
189	case WSAENOTCONN:
190	errstr = "Socket is not connected";
191	break;
192	case WSAESHUTDOWN:
193	errstr = "Socket has been shut down";
194	break;
195	case WSAETOOMANYREFS:
196	errstr = "Too many references";
197	break;
198	case WSAETIMEDOUT:
199	errstr = "Timed out";
200	break;
201	case WSAECONNREFUSED:
202	errstr = "Connection refused";
203	break;
204	case WSAELOOP:
205	errstr = "Loop??";
206	break;
207	case WSAENAMETOOLONG:
208	errstr = "Name too long";
209	break;
210	case WSAEHOSTDOWN:
211	errstr = "Host down";
212	break;
213	case WSAEHOSTUNREACH:
214	errstr = "Host unreachable";
215	break;
216	case WSAENOTEMPTY:
217	errstr = "Not empty";
218	break;
219	case WSAEPROCLIM:
220	errstr = "Process limit reached";
221	break;
222	case WSAEUSERS:
223	errstr = "Too many users";
224	break;
225	case WSAEDQUOT:
226	errstr = "Bad quota";
227	break;
228	case WSAESTALE:
229	errstr = "Something is stale";
230	break;
231	case WSAEREMOTE:
232	errstr = "Remote error";
233	break;
234	case WSAEDISCON:
235	errstr = "Disconnected";
236	break;
237
238	/* Extended Winsock errors */
239	case WSASYSNOTREADY:
240	errstr = "Winsock library is not ready";
241	break;
242	case WSANOTINITIALISED:
243	errstr = "Winsock library not initialised";
244	break;
245	case WSAVERNOTSUPPORTED:
246	errstr = "Winsock version not supported";
247	break;
248
249	/* getXbyY() errors (already handled in herrmsg):
250	* Authoritative Answer: Host not found */
251	case WSAHOST_NOT_FOUND:
252	errstr = "Host not found";
253	break;
254
255	/* Non-Authoritative: Host not found, or SERVERFAIL */
256	case WSATRY_AGAIN:
257	errstr = "Host not found, try again";
258	break;
259
260	/* Non recoverable errors, FORMERR, REFUSED, NOTIMP */
261	case WSANO_RECOVERY:
262	errstr = "Unrecoverable error in call to nameserver";
263	break;
264
265	/* Valid name, no data record of requested type */
266	case WSANO_DATA:
267	errstr = "No data record of requested type";
268	break;
269
270	default:
271	errstr = "Unknown error";
272	}
273
274	return errstr;
275	}
276
277	#else /* __MINGW32__ */
278
c4f23e30	279	#include <errno.h>
1cb3cdd7	280	#include <netdb.h>
c4f23e30 FD	281	#include <netinet/in.h>
	282	#include <sys/socket.h>
	283	#include <unistd.h>
	284
	285	#include <glib.h>
1cb3cdd7 MJ	286
	287	#define BT_INVALID_SOCKET -1
	288	#define BT_SOCKET_ERROR -1
	289	#define BT_SOCKET int
	290
	291	static inline
95c324a4	292	int bt_socket_init(int log_level)
1cb3cdd7 MJ	293	{
	294	return 0;
	295	}
	296
	297	static inline
	298	int bt_socket_fini(void)
	299	{
	300	return 0;
	301	}
	302
	303	static inline
	304	int bt_socket_send(int sockfd, const void *buf, size_t len, int flags)
	305	{
	306	return send(sockfd, buf, len, flags);
	307	}
	308
	309	static inline
	310	int bt_socket_recv(int sockfd, void *buf, size_t len, int flags)
	311	{
	312	return recv(sockfd, buf, len, flags);
	313	}
	314
	315	static inline
	316	int bt_socket_close(int fd)
	317	{
	318	return close(fd);
	319	}
	320
	321	static inline
	322	bool bt_socket_interrupted(void)
	323	{
	324	return (errno == EINTR);
	325	}
	326
	327	static inline
	328	const char *bt_socket_errormsg(void)
	329	{
	330	return g_strerror(errno);
	331	}
	332	#endif
	333
	334
	335	/*
	336	* This wrapper is used on platforms that have no way of ignoring SIGPIPE
	337	* during a send().
	338	*/
	339
	340	#ifndef MSG_NOSIGNAL
	341	# ifdef SO_NOSIGPIPE
	342	# define MSG_NOSIGNAL SO_NOSIGPIPE
	343	# elif defined(__MINGW32__)
	344	# define MSG_NOSIGNAL 0
	345	# endif
	346	#endif
	347
	348	#if defined(MSG_NOSIGNAL)
	349	static inline
	350	ssize_t bt_socket_send_nosigpipe(int fd, const void *buffer, size_t size)
	351	{
	352	return bt_socket_send(fd, buffer, size, MSG_NOSIGNAL);
	353	}
	354	#else
	355
	356	#include <signal.h>
357
358	static inline
359	ssize_t bt_socket_send_nosigpipe(int fd, const void *buffer, size_t size)
360	{
361	ssize_t sent;
362	int saved_err;
363	sigset_t sigpipe_set, pending_set, old_set;
364	int sigpipe_was_pending;
365
366	/*
367	* Discard the SIGPIPE from send(), not disturbing any SIGPIPE
368	* that might be already pending. If a bogus SIGPIPE is sent to
369	* the entire process concurrently by a malicious user, it may
370	* be simply discarded.
371	*/
372	if (sigemptyset(&pending_set)) {
373	return -1;
374	}
375	/*
376	* sigpending returns the mask of signals that are _both_
377	* blocked for the thread _and_ pending for either the thread or
378	* the entire process.
379	*/
380	if (sigpending(&pending_set)) {
381	return -1;
382	}
383	sigpipe_was_pending = sigismember(&pending_set, SIGPIPE);
384	/*
385	* If sigpipe was pending, it means it was already blocked, so
386	* no need to block it.
387	*/
388	if (!sigpipe_was_pending) {
389	if (sigemptyset(&sigpipe_set)) {
390	return -1;
391	}
392	if (sigaddset(&sigpipe_set, SIGPIPE)) {
393	return -1;
394	}
395	if (pthread_sigmask(SIG_BLOCK, &sigpipe_set, &old_set)) {
396	return -1;
397	}
398	}
399
400	/* Send and save errno. */
401	sent = bt_socket_send(fd, buffer, size, 0);
402	saved_err = errno;
403
404	if (sent == -1 && errno == EPIPE && !sigpipe_was_pending) {
405	struct timespec timeout = { 0, 0 };
406	int ret;
407
408	do {
409	ret = sigtimedwait(&sigpipe_set, NULL,
410	&timeout);
411	} while (ret == -1 && errno == EINTR);
412	}
413	if (!sigpipe_was_pending) {
414	if (pthread_sigmask(SIG_SETMASK, &old_set, NULL)) {
415	return -1;
416	}
417	}
418	/* Restore send() errno */
419	errno = saved_err;
420
421	return sent;
422	}
423	#endif
424
425
426	#endif /* _BABELTRACE_COMPAT_SOCKET_H */