3cf7852e03
git-svn-id: svn://kolibrios.org@5131 a494cfbc-eb01-0410-851d-a64ba20cac60
1002 lines
21 KiB
C
1002 lines
21 KiB
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;
|
|
}
|