ref: cd8c8d416b4245458460cfe8e3c00bcb69c3c45b
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; }