--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/libpurple/protocols/gg/lib/network.c Fri Feb 28 17:29:00 2014 +0100
@@ -0,0 +1,307 @@
+/*
+ * (C) Copyright 2011 Wojtek Kaniewski <wojtekka@irc.pl>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License Version
+ * 2.1 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307,
+ * USA.
+ */
+
+#include "network.h"
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef _WIN32
+
+/* Code losely based on sockerpair implementation by Nathan C. Meyrs.
+ * The original copyright notice follows: */
+
+/* socketpair.c
+ * Copyright 2007, 2010 by Nathan C. Myers <ncm@cantrip.org>
+ * This code is Free Software. It may be copied freely, in original or
+ * modified form, subject only to the restrictions that (1) the author is
+ * relieved from all responsibilities for any use for any purpose, and (2)
+ * this copyright notice must be retained, unchanged, in its entirety. If
+ * for any reason the author might be held responsible for any consequences
+ * of copying or use, license is withheld.
+ */
+
+int gg_win32_socketpair(int sv[2])
+{
+ struct sockaddr_in sin;
+ socklen_t sin_len = sizeof(sin);
+ int server = -1;
+ int tmp = 1;
+
+ server = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+
+ sv[0] = -1;
+ sv[1] = -1;
+
+ if (server == -1)
+ goto fail;
+
+ memset(&sin, 0, sizeof(sin));
+ sin.sin_family = AF_INET;
+ sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+ sin.sin_port = 0;
+
+ if (setsockopt(server, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp)) == -1)
+ goto fail;
+
+ if (bind(server, (struct sockaddr*) &sin, sin_len) == -1)
+ goto fail;
+
+ if (listen(server, 1) == -1)
+ goto fail;
+
+ if (getsockname(server, (struct sockaddr*) &sin, &sin_len) == -1)
+ goto fail;
+
+ sin.sin_family = AF_INET;
+ sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+
+ sv[0] = socket(AF_INET, SOCK_STREAM, 0);
+
+ if (sv[0] == -1)
+ goto fail;
+
+ if (connect(sv[0], (struct sockaddr*) &sin, sin_len) == -1)
+ goto fail;
+
+ sv[1] = accept(server, NULL, NULL);
+
+ if (sv[1] == -1)
+ goto fail;
+
+ close(server);
+
+ return 0;
+
+fail:
+ close(server);
+ close(sv[0]);
+ close(sv[1]);
+
+ return -1;
+}
+
+static int gg_win32_map_wsa_error_to_errno(int wsaewouldblock_map)
+{
+ int wsa_error;
+
+ wsa_error = WSAGetLastError();
+
+ /* Tutaj powinny być tłumaczone wszystkie typy błędów sprawdzane przez
+ * kod libgadu. Dla spójność są również tłumaczone typy błędów ustawiane
+ * przez libgadu.
+ * Ponadto gdyby okazało się, że jakaś aplikacja na Win32 chce móc
+ * polegać jeszcze na innych wartościach errno, można tutaj dodać
+ * ich tłumaczenie. Najpierw jednak zawsze trzeba porównać dokumentacje,
+ * aby upewnić się co do poprawności tłumaczenia (patrz WSAEWOULDBLOCK,
+ * które można tłumaczyć na EWOULDBLOCK lub EAGAIN, a nawet na
+ * EINPROGRESS w przypadku connect()).
+ */
+ switch (wsa_error)
+ {
+ /* Typy błędów sprawdzane przez libgadu. */
+ case WSAEINTR:
+ return EINTR;
+ case WSAEWOULDBLOCK:
+ return wsaewouldblock_map;
+ /* Typy błędów ustawiane przez libgadu. */
+ case WSAECONNRESET:
+ return ECONNRESET;
+ case WSAEFAULT:
+ return EFAULT;
+ case WSAEINVAL:
+ return EINVAL;
+ case WSAENOTCONN:
+ return ENOTCONN;
+ case WSAETIMEDOUT:
+ return ETIMEDOUT;
+ default:
+ /* Najlepiej zwrócić oryginalny kod błędu. I tak będzie co najwyżej
+ * wyświetlony w komunikacie debugowym, a tym sposobem będzie łatwiej
+ * dojść przyczyny problemu. */
+ return wsa_error;
+ }
+}
+
+#undef accept
+int gg_win32_accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)
+{
+ int res;
+
+ res = accept(sockfd, addr, addrlen);
+
+ if (res == -1)
+ errno = gg_win32_map_wsa_error_to_errno(EAGAIN);
+
+ return res;
+}
+
+#undef bind
+int gg_win32_bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
+{
+ int res;
+
+ res = bind(sockfd, addr, addrlen);
+
+ if (res == -1)
+ errno = gg_win32_map_wsa_error_to_errno(EAGAIN);
+
+ return res;
+}
+
+int gg_win32_close(int sockfd)
+{
+ int res;
+
+ res = closesocket(sockfd);
+
+ if (res == -1)
+ errno = gg_win32_map_wsa_error_to_errno(EAGAIN);
+
+ return res;
+}
+
+#undef connect
+int gg_win32_connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
+{
+ int res;
+
+ res = connect(sockfd, addr, addrlen);
+
+ if (res == -1)
+ errno = gg_win32_map_wsa_error_to_errno(EINPROGRESS);
+
+ return res;
+}
+
+#undef gethostbyname
+struct hostent *gg_win32_gethostbyname(const char *name)
+{
+ struct hostent *res;
+
+ res = gethostbyname(name);
+
+ if (res == NULL)
+ errno = gg_win32_map_wsa_error_to_errno(EAGAIN);
+
+ return res;
+}
+
+#undef getsockname
+int gg_win32_getsockname(int sockfd, struct sockaddr *addr, socklen_t *addrlen)
+{
+ int res;
+
+ res = getsockname(sockfd, addr, addrlen);
+
+ if (res == -1)
+ errno = gg_win32_map_wsa_error_to_errno(EAGAIN);
+
+ return res;
+}
+
+#undef getsockopt
+int gg_win32_getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen)
+{
+ int res;
+
+ res = getsockopt(sockfd, level, optname, optval, optlen);
+
+ if (res == -1)
+ errno = gg_win32_map_wsa_error_to_errno(EAGAIN);
+
+ return res;
+}
+
+int gg_win32_ioctl(int d, int request, int *argp)
+{
+ int res;
+
+ res = ioctlsocket(d, request, (u_long *)argp);
+
+ if (res == -1)
+ errno = gg_win32_map_wsa_error_to_errno(EAGAIN);
+
+ return res;
+}
+
+#undef listen
+int gg_win32_listen(int sockfd, int backlog)
+{
+ int res;
+
+ res = listen(sockfd, backlog);
+
+ if (res == -1)
+ errno = gg_win32_map_wsa_error_to_errno(EAGAIN);
+
+ return res;
+}
+
+#undef recv
+int gg_win32_recv(int sockfd, void *buf, size_t len, int flags)
+{
+ int res;
+
+ res = recv(sockfd, buf, len, flags);
+
+ if (res == -1)
+ errno = gg_win32_map_wsa_error_to_errno(EAGAIN);
+
+ return res;
+}
+
+#undef send
+int gg_win32_send(int sockfd, const void *buf, size_t len, int flags)
+{
+ int res;
+
+ res = send(sockfd, buf, len, flags);
+
+ if (res == -1)
+ errno = gg_win32_map_wsa_error_to_errno(EAGAIN);
+
+ return res;
+}
+
+#undef setsockopt
+int gg_win32_setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen)
+{
+ int res;
+
+ res = setsockopt(sockfd, level, optname, optval, optlen);
+
+ if (res == -1)
+ errno = gg_win32_map_wsa_error_to_errno(EAGAIN);
+
+ return res;
+}
+
+#undef socket
+int gg_win32_socket(int domain, int type, int protocol)
+{
+ int res;
+
+ res = socket(domain, type, protocol);
+
+ if (res == -1)
+ errno = gg_win32_map_wsa_error_to_errno(EAGAIN);
+
+ return res;
+}
+
+#endif /* _WIN32 */