ref: b8fdee42392c7a7692bb60483cc906dfa3acf62d
dir: /u/mplpc.c/
/*
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
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 General Public License for more details.
You should have received a copy of the GNU 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 <go32.h>
#include "mpdosock.h"
//#include "types.h"
typedef unsigned char BYTE;
typedef unsigned short WORD;
typedef unsigned long DWORD;
//#include "lpc.h"
typedef struct {
short version; // version of LPC requested
short sizeOfArgs; // size of arguments
short service; // service # requested
char Data[1]; // data
} LPCData;
typedef struct {
short version; // LPC version
short sizeOfReturn; // return data size
short error; // any error codes
short noRet; // number of returns
char Data[1]; // data
} LPCReturn;
//#include "services.h"
#define MAXSOCKETS 20
// services
#define LPC_SOCKBIND 4
#define LPC_SOCKGETHOSTBYNAME 5
#define LPC_SOCKGETHOSTNAME 6
#define LPC_SOCKGETHOSTBYADDR 7
#define LPC_SOCKCLOSE 8
#define LPC_SOCKSOCKET 9
#define LPC_SOCKRECVFROM 10
#define LPC_SOCKSENDTO 11
#define LPC_SOCKIOCTL 12
#define LPC_SOCKGETSOCKNAME 13
#define LPC_SOCKFLUSH 14
#define LPC_SOCKSETOPT 15
#define LPC_SOCKGETLASTERROR 16
#define LPC_SOCKINETADDR 17
// htons, ntohs, htonl, ntohl implemented locally
// errors
#define LPC_UNRECOGNIZED_SERVICE -1
#define LPC_NOERROR 0
// structures for support
typedef struct {
SOCKET s;
int namelen;
char name[1];
} BindArgs;
typedef struct {
SOCKET s;
long cmd;
char data[1];
} IoctlArgs;
typedef struct {
int retVal;
int namelen;
char name[1];
} GetSockNameRet;
typedef GetSockNameRet GetHostNameRet;
typedef struct {
int retVal;
int h_addr_0; // that's the only important value
} GetHostByNameRet;
typedef struct {
int len;
int type;
char addr[1];
} GetHostByAddrArgs;
typedef struct {
int retVal;
char h_name[1]; // h_name is the only important value
} GetHostByAddrRet;
typedef struct {
SOCKET s;
int flags;
} RecvFromArgs;
typedef struct {
int retVal;
int errCode;
int len; // message len
struct sockaddr sockaddr;
int sockaddrlen;
char Data[1];
} RecvFromRet;
typedef struct {
SOCKET s;
int flags;
int len;
struct sockaddr sockaddr;
int sockaddrlen;
char Data[1];
} SendToArgs;
typedef struct {
int retVal;
int errCode;
} SendToRet;
typedef struct {
int bufflen;
SOCKET s;
int len;
int sockaddrlen;
struct sockaddr address;
char data[1];
} SocketChannelData;
typedef struct {
int af;
int type;
int protocol;
} SocketArgs;
typedef struct {
SOCKET s;
int len;
int flags;
int addrlen;
struct sockaddr addr;
char data[1];
} WinSockData;
typedef struct {
SOCKET s;
int level;
int optname;
int optlen;
char optval[1];
} SetSockOptArgs;
typedef struct {
SOCKET sock[MAXSOCKETS];
} SocketMap;
//#include "rtq.h"
#define RTQ_NODE struct rtq_node
RTQ_NODE
{
RTQ_NODE *self; // Ring zero address of this node
RTQ_NODE *left; // Ring zero address of preceding node
RTQ_NODE *right; // Ring zero address of succeding node
BYTE * rtqDatum; // Ring 3 Datum of Buffer (start of preface)
BYTE * rtqInsert; // Ring 3 insertion position
WORD rtqLen; // Length of buffer, excluding preface
WORD rtqUpCtr; // Up Counter of bytes used so far
WORD rtqQCtr; // number of nodes attached
WORD padding; // DWORD alignment
};
#define RTQ_PARAM_MOVENODE struct rtq_param_movenode
RTQ_PARAM_MOVENODE
{
WORD rtqFromDQ;
WORD rtqToDQ;
};
RTQ_NODE* rtq_fetch(RTQ_NODE*, RTQ_NODE*); // To, From
//#include "mplib.h"
// give up time slice
void Yield(void);
void MGenWakeupDll(void);
// post a message to win32 side
void PostWindowsMessage(void);
// get # of items on qNo
int MGenGetQueueCtr(int qNo);
// move first node from qFrom to qTo
RTQ_NODE *MGenMoveTo(int qFrom, int qTo);
// get first node from q
RTQ_NODE *MGenGetNode(int q);
// get master node, returning size of RTQ_NODE for size verification
RTQ_NODE *MGenGetMasterNode(unsigned *size);
// move all nodes from qFrom to qTo
RTQ_NODE *MGenFlushNodes(int qFrom, int qTo);
// count number of nodes in queues designated by bitmask
// lowerOrderBits == 0..31, upperOrderBits == 32-63
int MGenMCount(unsigned lowerOrderBits, unsigned upperOrderBits);
// perform consistency check on chunnel address space
int MGenSanityCheck(void);
#include <stdio.h>
#include <sys/farptr.h>
extern short flat_selector;
#define SOCKET_MAP_QUEUE 41
#define IDLE_QUEUE 44
#define REC_QUEUE 45
#define SEND_QUEUE 46
// queue sizes
#define FREEQBASE 58
#define FREEQ64 58
#define FREEQ128 59
#define FREEQ256 60
#define FREEQ512 61
#define FREEQ1024 62
#define FREEQ2048 63
#define NFREEQ 6
#define QLIMIT 10
#define PRIVATEQ 50
#define FARPKL(x) (_farnspeekl((unsigned long) x))
#define FARPKB(x) (_farnspeekb((unsigned long) x))
#define FARPKS(x) (_farnspeekw((unsigned long) x))
#define FARPOKL(x, y) (_farnspokel((unsigned long) x, (unsigned long) y))
#define FARPOKB(x, y) (_farnspokeb((unsigned long) x, (unsigned char) y))
int Qsizes[] = { 64, 128, 256, 512, 1024, 2048 };
int SocketError = 0;
SocketMap *SockMap;
#define HOSTENT_ALIAS_LIMIT 5
#define HOSTENT_STRLEN_LIMIT 50
#define HOSTENT_ADDR_LIST_LIMIT 5
struct hostent HostEnt;
char HostEnt_hname[HOSTENT_STRLEN_LIMIT];
char *HostEnt_h_aliases[HOSTENT_ALIAS_LIMIT];
char HostEnt_names[HOSTENT_ALIAS_LIMIT][HOSTENT_STRLEN_LIMIT];
struct in_addr* HostEnt_addr_list[HOSTENT_ADDR_LIST_LIMIT];
struct in_addr HostEnt_addrs[HOSTENT_ADDR_LIST_LIMIT];
void
fmemcpyto(void *to, const void *from, int length)
{
movedata(_my_ds(), (unsigned)from, flat_selector, (unsigned)to, length);
}
void
fmemcpyfrom(void *to, const void *from, int length)
{
movedata(flat_selector, (unsigned)from, _my_ds(), (unsigned)to, length);
}
void
fstrcpyto(char *to, const char *from)
{
while (*from) {
FARPOKB(to, *from);
to++; from++;
}
FARPOKB(to, 0);
}
void
fstrncpyto(char *to, const char *from, int len)
{
while (*from && len) {
FARPOKB(to, *from);
to++; from++; len--;
}
FARPOKB(to, 0);
}
void
fstrcpyfrom(char *to, const char *from)
{
while (FARPKB(from)) {
*to = FARPKB(from);
from++; to++;
}
*to = 0;
}
void
fstrncpyfrom(char *to, const char *from, int len)
{
while (FARPKB(from) && len) {
*to = FARPKB(from);
from++; to++; len--;
}
*to = 0;
}
void
GetSocketMap(void)
{
RTQ_NODE *n = MGenGetNode(SOCKET_MAP_QUEUE);
SockMap = (SocketMap *) FARPKL(&n->rtqDatum);
}
void *
GetFreeBufferToQueue(int q, int bufSize)
{
int i;
for (i = 0; i < NFREEQ; i++) {
if (Qsizes[i] >= bufSize && MGenGetQueueCtr(i+FREEQBASE)) {
RTQ_NODE *n = MGenMoveTo(i+FREEQBASE, q);
if (!n)
continue;
FARPOKL(&n->rtqUpCtr, bufSize);
return (void *) FARPKL(&n->rtqDatum);
}
}
return 0;
}
void
FreeBufferFromQueue(int q)
{
int i;
RTQ_NODE *n = MGenGetNode(q);
for (i = 0; i < NFREEQ; i++) {
if (Qsizes[i] == FARPKS(&n->rtqLen)) {
MGenMoveTo(q, i+FREEQBASE);
return;
}
}
}
void
SetLPCData(LPCData *lpc)
{
FARPOKL(&(lpc->version), 1);
FARPOKL(&(lpc->sizeOfArgs), 0);
FARPOKL(&(lpc->service), 0);
}
int
bind(SOCKET s, const struct sockaddr *name, int namelen)
{
RTQ_NODE *n = MGenGetNode(IDLE_QUEUE);
LPCData *p;
LPCReturn *r;
BindArgs *bargs;
int retVal;
_farsetsel(flat_selector);
SocketError = 0;
p = (LPCData *) FARPKL(&n->rtqDatum);
SetLPCData(p);
FARPOKL(&p->service, LPC_SOCKBIND);
bargs = (BindArgs *) p->Data;
FARPOKL(&bargs->s, s);
FARPOKL(&bargs->namelen, namelen);
fmemcpyto(bargs->name, name, namelen);
MGenMoveTo(IDLE_QUEUE, SEND_QUEUE);
PostWindowsMessage();
while ((n = MGenGetNode(REC_QUEUE)) == 0)
Yield();
r = (LPCReturn *) FARPKL(&n->rtqDatum);
if (FARPKS(&r->error) != LPC_NOERROR) {
return -1;
}
retVal = FARPKL(r->Data);
// get ready for next call
MGenMoveTo(REC_QUEUE, IDLE_QUEUE);
return retVal;
}
int
closesocket(SOCKET s)
{
RTQ_NODE *n = MGenGetNode(IDLE_QUEUE);
LPCData *p;
LPCReturn *r;
int retVal;
_farsetsel(flat_selector);
SocketError = 0;
p = (LPCData *) FARPKL(&n->rtqDatum);
SetLPCData(p);
FARPOKL(&p->service, LPC_SOCKCLOSE);
FARPOKL(p->Data, s);
MGenMoveTo(IDLE_QUEUE, SEND_QUEUE);
PostWindowsMessage();
while ((n = MGenGetNode(REC_QUEUE)) == 0)
Yield();
r = (LPCReturn *) FARPKL(&n->rtqDatum);
if (FARPKS(&r->error) != LPC_NOERROR) {
return -1;
}
retVal = FARPKL(r->Data);
// get ready for next call
MGenMoveTo(REC_QUEUE, IDLE_QUEUE);
return retVal;
}
void
ZapHostEnt()
{
// do nothing
}
void
ReconstructHostEnt(struct hostent *s, void *flattened)
{
struct hostent *old = (struct hostent *) flattened;
int i;
char **ptr;
s->h_name = HostEnt_hname;
fstrncpyfrom(s->h_name, (char *) FARPKL(&old->h_name), HOSTENT_STRLEN_LIMIT-1);
s->h_name[HOSTENT_STRLEN_LIMIT-1] = 0;
s->h_aliases = HostEnt_h_aliases;
ptr = (char **) FARPKL(&old->h_aliases);
for (i = 0; i < (HOSTENT_ALIAS_LIMIT-1) && FARPKL(ptr); i++, ptr++) {
s->h_aliases[i] = HostEnt_names[i];
// fstrncpyfrom(s->h_aliases[i], (void *) FARPKL(ptr), HOSTENT_STRLEN_LIMIT-1);
s->h_aliases[i][HOSTENT_STRLEN_LIMIT-1] = 0;
}
s->h_aliases[i] = 0;
s->h_addrtype = FARPKS(&old->h_addrtype);
s->h_length = FARPKS(&old->h_length);
if (FARPKS(&old->h_length) != sizeof(struct in_addr)) {
printf("Error!\n");
exit(0);
}
s->h_addr_list = (char **) HostEnt_addr_list;
ptr = (char **) FARPKL(&old->h_addr_list);
for (i = 0; i < (HOSTENT_ADDR_LIST_LIMIT - 1) && FARPKL(ptr); i++, ptr++) {
s->h_addr_list[i] = (char *) &(HostEnt_addrs[i]);
fmemcpyfrom(s->h_addr_list[i], (void *) FARPKL(ptr), s->h_length);
}
s->h_addr_list[i] = 0;
}
int
getsockname(SOCKET s, struct sockaddr *name, int *namelen)
{
RTQ_NODE *n = MGenGetNode(IDLE_QUEUE);
LPCData *p;
LPCReturn *r;
GetSockNameRet *ret;
int retVal;
SocketError = 0;
_farsetsel(flat_selector);
p = (LPCData *) FARPKL(&n->rtqDatum);
SetLPCData(p);
FARPOKL(&p->service, LPC_SOCKGETSOCKNAME);
FARPOKL(p->Data, s);
MGenMoveTo(IDLE_QUEUE, SEND_QUEUE);
PostWindowsMessage();
while ((n = MGenGetNode(REC_QUEUE)) == 0)
Yield();
r = (LPCReturn *) FARPKL(&n->rtqDatum);
if (FARPKS(&r->error) != LPC_NOERROR) {
return -1;
}
ret = (GetSockNameRet *) r->Data;
retVal = FARPKL(&ret->retVal);
fmemcpyfrom(name, ret->name, FARPKL(&ret->namelen));
*namelen = FARPKL(&ret->namelen);
// get ready for next call
MGenMoveTo(REC_QUEUE, IDLE_QUEUE);
return retVal;
}
int
gethostname(char *name, int namelen)
{
RTQ_NODE *n;
LPCData *p;
LPCReturn *r;
GetHostNameRet *ret;
int retVal;
char *s;
_farsetsel(flat_selector);
SocketError = 0;
n = (RTQ_NODE *) MGenGetNode(IDLE_QUEUE);
p = (LPCData *) FARPKL(&n->rtqDatum);
SetLPCData(p);
FARPOKL(&p->service,LPC_SOCKGETHOSTNAME);
MGenMoveTo(IDLE_QUEUE, SEND_QUEUE);
PostWindowsMessage();
while ((n = (RTQ_NODE *) (MGenGetNode(REC_QUEUE))) == 0)
Yield();
r = (LPCReturn *) FARPKL(&n->rtqDatum);
if (FARPKS(&r->error) != LPC_NOERROR) {
return -1;
}
ret = (GetHostNameRet *) r->Data;
retVal = FARPKL(&ret->retVal);
s = ret->name;
fstrncpyfrom(name, s, namelen);
#if 0
len = strlen(ret->name);
if (len > namelen)
memcpy(name, ret->name, ret->namelen);
else
strcpy(name, ret->name);
#endif
// get ready for next call
MGenMoveTo(REC_QUEUE, IDLE_QUEUE);
return retVal;
}
struct hostent *
gethostbyname(const char *name)
{
RTQ_NODE *n = MGenGetNode(IDLE_QUEUE);
LPCData *p;
LPCReturn *r;
struct hostent *retVal;
_farsetsel(flat_selector);
SocketError = 0;
p = (LPCData *) FARPKL(&n->rtqDatum);
SetLPCData(p);
FARPOKL(&p->service, LPC_SOCKGETHOSTBYNAME);
fstrcpyto(p->Data, name);
MGenMoveTo(IDLE_QUEUE, SEND_QUEUE);
PostWindowsMessage();
while ((n = MGenGetNode(REC_QUEUE)) == 0)
Yield();
r = (LPCReturn *) FARPKL(&n->rtqDatum);
retVal = (struct hostent *) r->Data;
if (FARPKL(&retVal->h_name) == 0) {
retVal = 0;
} else {
ZapHostEnt();
ReconstructHostEnt(&HostEnt, (void *) retVal);
retVal = &HostEnt;
}
// get ready for next call
MGenMoveTo(REC_QUEUE, IDLE_QUEUE);
return retVal;
}
struct hostent *
gethostbyaddr(const char *addr, int len, int type)
{
RTQ_NODE *n = MGenGetNode(IDLE_QUEUE);
LPCData *p;
LPCReturn *r;
GetHostByAddrArgs *args;
struct hostent *retVal;
SocketError = 0;
_farsetsel(flat_selector);
p = (LPCData *) FARPKL(&n->rtqDatum);
SetLPCData(p);
FARPOKL(&p->service, LPC_SOCKGETHOSTBYADDR);
args = (GetHostByAddrArgs *) p->Data;
FARPOKL(&args->len, len);
FARPOKL(&args->type, type);
fmemcpyto(args->addr, addr, len);
MGenMoveTo(IDLE_QUEUE, SEND_QUEUE);
PostWindowsMessage();
while ((n = MGenGetNode(REC_QUEUE)) == 0)
Yield();
r = (LPCReturn *) FARPKL(&n->rtqDatum);
retVal = (struct hostent *) r->Data;
if (FARPKL(&retVal->h_name) == 0) {
retVal = 0;
} else {
ZapHostEnt();
ReconstructHostEnt(&HostEnt, (void *) retVal);
retVal = &HostEnt;
}
// get ready for next call
MGenMoveTo(REC_QUEUE, IDLE_QUEUE);
return retVal;
}
SOCKET
socket(int af, int type, int protocol)
{
RTQ_NODE *n = MGenGetNode(IDLE_QUEUE);
LPCData *p;
LPCReturn *r;
SocketArgs *args;
int retVal;
_farsetsel(flat_selector);
SocketError = 0;
p = (LPCData *) FARPKL(&n->rtqDatum);
SetLPCData(p);
FARPOKL(&p->service, LPC_SOCKSOCKET);
args = (SocketArgs *) p->Data;
FARPOKL(&args->af, af);
FARPOKL(&args->type, type);
FARPOKL(&args->protocol, protocol);
MGenMoveTo(IDLE_QUEUE, SEND_QUEUE);
PostWindowsMessage();
while ((n = MGenGetNode(REC_QUEUE)) == 0)
Yield();
r = (LPCReturn *) FARPKL(&n->rtqDatum);
if (FARPKS(&r->error) != LPC_NOERROR) {
return -1;
}
retVal = FARPKL(r->Data);
// get ready for next call
MGenMoveTo(REC_QUEUE, IDLE_QUEUE);
return retVal;
}
void
sockets_flush(void)
{
RTQ_NODE *n = MGenGetNode(IDLE_QUEUE);
LPCData *p;
SocketError = 0;
p = (LPCData *) FARPKL(&n->rtqDatum);
SetLPCData(p);
FARPOKL(&p->service, LPC_SOCKFLUSH);
MGenMoveTo(IDLE_QUEUE, SEND_QUEUE);
PostWindowsMessage();
while ((n = MGenGetNode(REC_QUEUE)) == 0)
Yield();
MGenMoveTo(REC_QUEUE, IDLE_QUEUE);
}
int
recvfrom(SOCKET s, char *buf, int len, int flags, struct sockaddr *from,
int *fromlen)
{
int i;
RTQ_NODE *n;
WinSockData *data;
int bytesRead;
SocketError = 0;
_farsetsel(flat_selector);
if (!SockMap)
GetSocketMap();
for (i = 0; i < MAXSOCKETS; i++) {
if (FARPKL(&(SockMap->sock[i])) == s)
break;
}
if (i == MAXSOCKETS)
return SOCKET_ERROR;
// pick up node
n = MGenGetNode(i);
if (n == 0) {
SocketError = WSAEWOULDBLOCK;
return -1;
}
data = (WinSockData *) FARPKL(&n->rtqDatum);
bytesRead = FARPKL(&data->len);
if (from) {
fmemcpyfrom(from, &data->addr, sizeof(struct sockaddr));
}
if (fromlen) {
*fromlen = FARPKL(&data->addrlen);
}
fmemcpyfrom(buf, data->data, len > bytesRead ? bytesRead : len);
if ((flags & MSG_PEEK) == 0) {
FreeBufferFromQueue(i);
}
return bytesRead;
}
int
sendto(SOCKET s, const char *buf, int len, int flags, const struct sockaddr *to, int tolen)
{
int i;
int outQ;
WinSockData *data;
SocketError = 0;
_farsetsel(flat_selector);
if (!SockMap)
GetSocketMap();
for (i = 0; i < MAXSOCKETS; i++) {
if (FARPKL(&SockMap->sock[i]) == s) {
break;
}
}
if (i == MAXSOCKETS) {
SocketError = WSAENOTSOCK;
return SOCKET_ERROR;
}
outQ = i + MAXSOCKETS;
if (MGenGetQueueCtr(outQ) >= QLIMIT) {
SocketError = WSAEWOULDBLOCK;
return SOCKET_ERROR;
}
data = GetFreeBufferToQueue(PRIVATEQ, len + sizeof(WinSockData));
if (!data) {
SocketError = WSAEWOULDBLOCK;
return SOCKET_ERROR;
}
FARPOKL(&data->s, s);
FARPOKL(&data->len, len);
if (to) {
fmemcpyto(&data->addr, to, tolen);
FARPOKL(&data->addrlen, tolen);
} else {
FARPOKL(&data->addrlen, 0);
}
FARPOKL(&data->flags, flags);
fmemcpyto(data->data, buf, len);
MGenMoveTo(PRIVATEQ, outQ);
return len;
}
int
ioctlsocket(SOCKET s, long cmd, unsigned long *argp)
{
RTQ_NODE *n = MGenGetNode(IDLE_QUEUE);
LPCData *p;
LPCReturn *r;
IoctlArgs *args;
int retVal;
SocketError = 0;
_farsetsel(flat_selector);
p = (LPCData *) FARPKL(&n->rtqDatum);
SetLPCData(p);
FARPOKL(&p->service, LPC_SOCKIOCTL);
args = (IoctlArgs *) p->Data;
FARPOKL(&args->s, s);
FARPOKL(&args->cmd, cmd);
switch(cmd) {
case FIONBIO:
FARPOKL(args->data, *argp);
break;
default:
return SOCKET_ERROR;
}
MGenMoveTo(IDLE_QUEUE, SEND_QUEUE);
PostWindowsMessage();
while ((n = MGenGetNode(REC_QUEUE)) == 0)
Yield();
r = (LPCReturn *) FARPKL(&n->rtqDatum);
retVal = FARPKL(r->Data);
// get ready for next call
MGenMoveTo(REC_QUEUE, IDLE_QUEUE);
return retVal;
}
int
setsockopt(SOCKET s, int level, int optname, const char *optval, int optlen)
{
RTQ_NODE *n = MGenGetNode(IDLE_QUEUE);
LPCData *p;
LPCReturn *r;
SetSockOptArgs *args;
int retVal;
SocketError = 0;
_farsetsel(flat_selector);
p = (LPCData *) FARPKL(&n->rtqDatum);
SetLPCData(p);
FARPOKL(&p->service, LPC_SOCKSETOPT);
args = (SetSockOptArgs *) p->Data;
FARPOKL(&args->s, s);
FARPOKL(&args->level, level);
FARPOKL(&args->optname, optname);
FARPOKL(&args->optlen, optlen);
fmemcpyto(args->optval, optval, optlen);
MGenMoveTo(IDLE_QUEUE, SEND_QUEUE);
PostWindowsMessage();
while ((n = MGenGetNode(REC_QUEUE)) == 0)
Yield();
r = (LPCReturn *) FARPKL(&n->rtqDatum);
retVal = FARPKL(r->Data);
// get ready for next call
MGenMoveTo(REC_QUEUE, IDLE_QUEUE);
return retVal;
}
int
WSAGetLastError(void)
{
RTQ_NODE *n = MGenGetNode(IDLE_QUEUE);
LPCData *p;
LPCReturn *r;
int retVal;
_farsetsel(flat_selector);
if (SocketError) {
int err = SocketError;
SocketError = 0;
return err;
}
p = (LPCData *) FARPKL(&n->rtqDatum);
SetLPCData(p);
FARPOKL(&p->service, LPC_SOCKGETLASTERROR);
MGenMoveTo(IDLE_QUEUE, SEND_QUEUE);
PostWindowsMessage();
while ((n = MGenGetNode(REC_QUEUE)) == 0)
Yield();
r = (LPCReturn *) FARPKL(&n->rtqDatum);
retVal = FARPKL(r->Data);
// get ready for next call
MGenMoveTo(REC_QUEUE, IDLE_QUEUE);
return retVal;
}
unsigned long inet_addr(const char *cp)
{
int ret;
unsigned int ha1, ha2, ha3, ha4;
unsigned long ipaddr;
ret = sscanf(cp, "%d.%d.%d.%d", &ha1, &ha2, &ha3, &ha4);
if (ret != 4)
return -1;
ipaddr = (ha1 << 24) | (ha2 << 16) | (ha3 << 8) | ha4;
return ipaddr;
#if 0
RTQ_NODE *n = MGenGetNode(IDLE_QUEUE);
LPCData *p;
LPCReturn *r;
int retVal;
SocketError = 0;
_farsetsel(flat_selector);
p = (LPCData *) FARPKL(&n->rtqDatum);
SetLPCData(p);
FARPOKL(&p->service, LPC_SOCKINETADDR);
fstrcpyto(p->Data, cp);
MGenMoveTo(IDLE_QUEUE, SEND_QUEUE);
PostWindowsMessage();
while ((n = MGenGetNode(REC_QUEUE)) == 0)
Yield();
r = (LPCReturn *) FARPKL(&n->rtqDatum);
if (FARPKS(&r->error) != LPC_NOERROR) {
return -1;
}
retVal = FARPKL(r->Data);
// get ready for next call
MGenMoveTo(REC_QUEUE, IDLE_QUEUE);
return retVal;
#endif
}
char *inet_ntoa (struct in_addr in)
{
static char buf [32];
sprintf(buf, "%u.%u.%u.%u", in.S_un.S_un_b.s_b1, in.S_un.S_un_b.s_b2, in.S_un.S_un_b.s_b3, in.S_un.S_un_b.s_b4);
return buf;
}