472 lines
9.3 KiB
C
472 lines
9.3 KiB
C
/*
|
|
* based on Windows Sockets 1.1 specs
|
|
* (ftp.microsoft.com:/Advsys/winsock/spec11/WINSOCK.TXT)
|
|
*
|
|
* (C) 1993,1994 John Brezak, Erik Bos.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <netinet/in.h>
|
|
#include <arpa/inet.h>
|
|
#include <errno.h>
|
|
#include <netdb.h>
|
|
#include <unistd.h>
|
|
#include "winsock.h"
|
|
|
|
#define DEBUG_WINSOCK
|
|
|
|
/* XXX per task */
|
|
WORD wsa_errno;
|
|
int wsa_initted;
|
|
|
|
WORD errno_to_wsaerrno(int errno)
|
|
{
|
|
switch(errno) {
|
|
case ENETDOWN:
|
|
return WSAENETDOWN;
|
|
case EAFNOSUPPORT:
|
|
return WSAEAFNOSUPPORT;
|
|
case EMFILE:
|
|
return WSAEMFILE;
|
|
case ENOBUFS:
|
|
return WSAENOBUFS;
|
|
case EPROTONOSUPPORT:
|
|
return EPROTONOSUPPORT;
|
|
case EPROTOTYPE:
|
|
return WSAEPROTOTYPE;
|
|
case EBADF:
|
|
case ENOTSOCK:
|
|
return WSAENOTSOCK;
|
|
|
|
default:
|
|
#ifndef sun
|
|
#if defined(__FreeBSD__)
|
|
fprintf(stderr, "winsock: errno_to_wsaerrno translation failure.\n\t: %s (%d)\n",
|
|
sys_errlist[errno], errno);
|
|
#else
|
|
fprintf(stderr, "winsock: errno_to_wsaerrno translation failure.\n\t: %s (%d)\n",
|
|
strerror[errno], errno);
|
|
#endif
|
|
#else
|
|
fprintf (stderr, "winsock: errno_to_wsaerrno translation failure.\n");
|
|
#endif
|
|
return WSAENETDOWN;
|
|
}
|
|
}
|
|
|
|
SOCKET Winsock_accept(SOCKET s, struct sockaddr FAR *addr, int FAR *addrlen)
|
|
{
|
|
int sock;
|
|
|
|
if ((sock = accept(s, addr, addrlen)) < 0) {
|
|
wsa_errno = errno_to_wsaerrno(errno);
|
|
return INVALID_SOCKET;
|
|
}
|
|
return sock;
|
|
}
|
|
|
|
int Winsock_bind(SOCKET s, struct sockaddr FAR *name, int namelen)
|
|
{
|
|
if (bind(s, name, namelen) < 0) {
|
|
wsa_errno = errno_to_wsaerrno(errno);
|
|
return SOCKET_ERROR;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int Winsock_closesocket(SOCKET s)
|
|
{
|
|
if (close(s) < 0) {
|
|
wsa_errno = errno_to_wsaerrno(errno);
|
|
return SOCKET_ERROR;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int Winsock_connect(SOCKET s, struct sockaddr FAR *name, int namelen)
|
|
{
|
|
if (connect(s, name, namelen) < 0) {
|
|
wsa_errno = errno_to_wsaerrno(errno);
|
|
return SOCKET_ERROR;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int Winsock_getpeername(SOCKET s, struct sockaddr FAR *name, int FAR *namelen)
|
|
{
|
|
if (getpeername(s, name, namelen) < 0) {
|
|
wsa_errno = errno_to_wsaerrno(errno);
|
|
return SOCKET_ERROR;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int Winsock_getsockname(SOCKET s, struct sockaddr FAR *name, int FAR *namelen)
|
|
{
|
|
if (getsockname(s, name, namelen) < 0) {
|
|
wsa_errno = errno_to_wsaerrno(errno);
|
|
return SOCKET_ERROR;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int Winsock_getsockopt(SOCKET s, int loptname, char FAR *optval, int FAR *optlen)
|
|
{
|
|
if (getsockopt(s, 0, loptname, optval, optlen) < 0) {
|
|
wsa_errno = errno_to_wsaerrno(errno);
|
|
return SOCKET_ERROR;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
u_long Winsock_htonl(u_long hostlong)
|
|
{
|
|
return( htonl(hostlong) );
|
|
}
|
|
|
|
u_short Winsock_htons(u_short hostshort)
|
|
{
|
|
return( htons(hostshort) );
|
|
}
|
|
|
|
u_long Winsock_inet_addr(char FAR *cp)
|
|
{
|
|
return( inet_addr(cp) );
|
|
}
|
|
|
|
char *Winsock_inet_ntoa(struct in_addr in)
|
|
{
|
|
char *s;
|
|
|
|
if ((s = inet_ntoa(in)) == NULL) {
|
|
wsa_errno = errno_to_wsaerrno(errno);
|
|
return NULL;
|
|
}
|
|
return s;
|
|
}
|
|
|
|
int Winsock_ioctlsocket(SOCKET s, long cmd, u_long FAR *argp)
|
|
{
|
|
if (ioctl(s, cmd, argp) < 0) {
|
|
wsa_errno = errno_to_wsaerrno(errno);
|
|
return SOCKET_ERROR;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int Winsock_listen(SOCKET s, int backlog)
|
|
{
|
|
if (listen(s, backlog) < 0) {
|
|
wsa_errno = errno_to_wsaerrno(errno);
|
|
return SOCKET_ERROR;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
u_long Winsock_ntohl(u_long netlong)
|
|
{
|
|
return( ntohl(netlong) );
|
|
}
|
|
|
|
u_short Winsock_ntohs(u_short netshort)
|
|
{
|
|
return( ntohs(netshort) );
|
|
}
|
|
|
|
int Winsock_recv(SOCKET s, char FAR *buf, int len, int flags)
|
|
{
|
|
int length;
|
|
|
|
if ((length = recv(s, buf, len, flags)) < 0) {
|
|
wsa_errno = errno_to_wsaerrno(errno);
|
|
return SOCKET_ERROR;
|
|
}
|
|
return length;
|
|
}
|
|
|
|
int Winsock_recvfrom(SOCKET s, char FAR *buf, int len, int flags,
|
|
struct sockaddr FAR *from, int FAR *fromlen)
|
|
{
|
|
int length;
|
|
|
|
if ((length = recvfrom(s, buf, len, flags, from, fromlen)) < 0) {
|
|
wsa_errno = errno_to_wsaerrno(errno);
|
|
return SOCKET_ERROR;
|
|
}
|
|
return length;
|
|
}
|
|
|
|
int Winsock_select(int nfds, fd_set FAR *readfds, fd_set FAR *writefds,
|
|
fd_set FAR *exceptfds, struct timeval FAR *timeout)
|
|
{
|
|
return(select(nfds, readfds, writefds, exceptfds, timeout));
|
|
}
|
|
|
|
int Winsock_send(SOCKET s, char FAR *buf, int len, int flags)
|
|
{
|
|
int length;
|
|
|
|
if ((length = send(s, buf, len, flags)) < 0) {
|
|
wsa_errno = errno_to_wsaerrno(errno);
|
|
return SOCKET_ERROR;
|
|
}
|
|
return length;
|
|
}
|
|
|
|
int Winsock_sendto(SOCKET s, char FAR *buf, int len, int flags,
|
|
struct sockaddr FAR *to, int tolen)
|
|
{
|
|
int length;
|
|
|
|
if ((length = sendto(s, buf, len, flags, to, tolen)) < 0) {
|
|
wsa_errno = errno_to_wsaerrno(errno);
|
|
return SOCKET_ERROR;
|
|
}
|
|
return length;
|
|
}
|
|
|
|
int Winsock_setsockopt(SOCKET s, int level, int optname, const char FAR *optval,
|
|
int optlen)
|
|
{
|
|
if (setsockopt(s, level, optname, optval, optlen) < 0) {
|
|
wsa_errno = errno_to_wsaerrno(errno);
|
|
return SOCKET_ERROR;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int Winsock_shutdown(SOCKET s, int how)
|
|
{
|
|
if (shutdown(s, how) < 0) {
|
|
wsa_errno = errno_to_wsaerrno(errno);
|
|
return SOCKET_ERROR;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
SOCKET Winsock_socket(WORD af, WORD type, WORD protocol)
|
|
{
|
|
int sock;
|
|
|
|
#ifdef DEBUG_WINSOCK
|
|
printf("Winsock_socket: af=%d type=%d protocol=%d\n", af, type, protocol);
|
|
#endif
|
|
|
|
/* let the kernel do the dirty work..
|
|
|
|
if (!wsa_initted) {
|
|
wsa_errno = WSANOTINITIALISED;
|
|
return INVALID_SOCKET;
|
|
}
|
|
*/
|
|
if ((sock = socket(af, type, protocol)) < 0) {
|
|
wsa_errno = errno_to_wsaerrno(errno);
|
|
return INVALID_SOCKET;
|
|
}
|
|
return sock;
|
|
}
|
|
|
|
struct hostent *Winsock_gethostbyaddr(const char FAR *addr, int len, int type)
|
|
{
|
|
struct hostent *host;
|
|
|
|
if ((host = gethostbyaddr(addr, len, type)) == NULL) {
|
|
wsa_errno = errno_to_wsaerrno(errno);
|
|
return NULL;
|
|
}
|
|
return host;
|
|
}
|
|
|
|
struct hostent *Winsock_gethostbyname(const char FAR *name)
|
|
{
|
|
struct hostent *host;
|
|
|
|
if ((host = gethostbyname(name)) == NULL) {
|
|
wsa_errno = errno_to_wsaerrno(errno);
|
|
return NULL;
|
|
}
|
|
return host;
|
|
}
|
|
|
|
int Winsock_gethostname(char FAR *name, int namelen)
|
|
{
|
|
if (gethostname(name, namelen) < 0) {
|
|
wsa_errno = errno_to_wsaerrno(errno);
|
|
return SOCKET_ERROR;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
struct protoent *Winsock_getprotobyname(char FAR *name)
|
|
{
|
|
struct protoent *proto;
|
|
|
|
if ((proto = getprotobyname(name)) == NULL) {
|
|
wsa_errno = errno_to_wsaerrno(errno);
|
|
return NULL;
|
|
}
|
|
return proto;
|
|
}
|
|
|
|
struct protoent *Winsock_getprotobynumber(int number)
|
|
{
|
|
struct protoent *proto;
|
|
|
|
if ((proto = getprotobynumber(number)) == NULL) {
|
|
wsa_errno = errno_to_wsaerrno(errno);
|
|
return NULL;
|
|
}
|
|
return proto;
|
|
}
|
|
|
|
struct servent *Winsock_getservbyname(const char FAR *name, const char FAR *proto)
|
|
{
|
|
struct servent *service;
|
|
|
|
if ((service = getservbyname(name, proto)) == NULL) {
|
|
wsa_errno = errno_to_wsaerrno(errno);
|
|
return NULL;
|
|
}
|
|
return service;
|
|
}
|
|
|
|
struct servent *Winsock_getservbyport(int port, const char FAR *proto)
|
|
{
|
|
struct servent *service;
|
|
|
|
if ((service = getservbyport(port, proto)) == NULL) {
|
|
wsa_errno = errno_to_wsaerrno(errno);
|
|
return NULL;
|
|
}
|
|
return service;
|
|
}
|
|
|
|
HANDLE WSAAsyncGetHostByAddr(HWND hWnd, u_int wMsg, const char FAR *addr,
|
|
int len, int type, const char FAR *buf, int buflen)
|
|
{
|
|
|
|
}
|
|
|
|
HANDLE WSAAsyncGetHostByName(HWND hWnd, u_int wMsg, const char FAR *name,
|
|
char FAR *buf, int buflen)
|
|
{
|
|
|
|
}
|
|
|
|
HANDLE WSAAsyncGetProtoByName(HWND hWnd, u_int wMsg, const char FAR *name,
|
|
char FAR *buf, int buflen)
|
|
{
|
|
|
|
}
|
|
|
|
HANDLE WSAAsyncGetProtoByNumber(HWND hWnd, u_int wMsg, int number,
|
|
char FAR *buf, int buflen)
|
|
{
|
|
|
|
}
|
|
|
|
HANDLE WSAAsyncGetServByName(HWND hWnd, u_int wMsg, const char FAR *name,
|
|
const char FAR *proto, char FAR *buf, int buflen)
|
|
{
|
|
|
|
}
|
|
|
|
HANDLE WSAAsyncGetServByPort(HWND hWnd, u_int wMsg, int port, const char FAR
|
|
*proto, char FAR *buf, int buflen)
|
|
{
|
|
|
|
}
|
|
|
|
int WSAAsyncSelect(SOCKET s, HWND hWnd, u_int wMsg, long lEvent)
|
|
{
|
|
|
|
}
|
|
|
|
int WSAFDIsSet(int fd, fd_set *set)
|
|
{
|
|
return( FD_ISSET(fd, set) );
|
|
}
|
|
|
|
WSACancelAsyncRequest(HANDLE hAsyncTaskHandle)
|
|
{
|
|
|
|
}
|
|
|
|
WSACancelBlockingCall ( void )
|
|
{
|
|
|
|
}
|
|
|
|
int WSAGetLastError(void)
|
|
{
|
|
return wsa_errno;
|
|
}
|
|
|
|
void WSASetLastError(int iError)
|
|
{
|
|
wsa_errno = iError;
|
|
}
|
|
|
|
BOOL WSAIsBlocking (void)
|
|
{
|
|
|
|
}
|
|
|
|
FARPROC WSASetBlockingHook(FARPROC lpBlockFunc)
|
|
{
|
|
|
|
}
|
|
|
|
int WSAUnhookBlockingHook(void)
|
|
{
|
|
|
|
}
|
|
|
|
WSADATA Winsock_data = {
|
|
0x0101,
|
|
0x0101,
|
|
"WINE Sockets",
|
|
#ifdef linux
|
|
"LINUX/i386",
|
|
#endif
|
|
#ifdef __NetBSD__
|
|
"NetBSD/i386",
|
|
#endif
|
|
#ifdef sunos
|
|
"SunOS",
|
|
#endif
|
|
128,
|
|
1024,
|
|
NULL
|
|
};
|
|
|
|
int WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData)
|
|
{
|
|
#ifdef DEBUG_WINSOCK
|
|
fprintf(stderr, "WSAStartup: verReq=%x\n", wVersionRequested);
|
|
#endif
|
|
|
|
if (LOBYTE(wVersionRequested) < 1 ||
|
|
(LOBYTE(wVersionRequested) == 1 &&
|
|
HIBYTE(wVersionRequested) < 1))
|
|
return WSAVERNOTSUPPORTED;
|
|
|
|
if (!lpWSAData)
|
|
return WSAEINVAL;
|
|
|
|
bcopy(&Winsock_data, lpWSAData, sizeof(Winsock_data));
|
|
|
|
wsa_initted = 1;
|
|
|
|
return(0);
|
|
}
|
|
|
|
int WSACleanup(void)
|
|
{
|
|
wsa_initted = 0;
|
|
return 0;
|
|
}
|