1*647f063dSAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
3*647f063dSAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4*647f063dSAndrew Rist * or more contributor license agreements. See the NOTICE file
5*647f063dSAndrew Rist * distributed with this work for additional information
6*647f063dSAndrew Rist * regarding copyright ownership. The ASF licenses this file
7*647f063dSAndrew Rist * to you under the Apache License, Version 2.0 (the
8*647f063dSAndrew Rist * "License"); you may not use this file except in compliance
9*647f063dSAndrew Rist * with the License. You may obtain a copy of the License at
10*647f063dSAndrew Rist *
11*647f063dSAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
12*647f063dSAndrew Rist *
13*647f063dSAndrew Rist * Unless required by applicable law or agreed to in writing,
14*647f063dSAndrew Rist * software distributed under the License is distributed on an
15*647f063dSAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*647f063dSAndrew Rist * KIND, either express or implied. See the License for the
17*647f063dSAndrew Rist * specific language governing permissions and limitations
18*647f063dSAndrew Rist * under the License.
19*647f063dSAndrew Rist *
20*647f063dSAndrew Rist *************************************************************/
21*647f063dSAndrew Rist
22*647f063dSAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir #include "system.h"
25cdf0e10cSrcweir
26cdf0e10cSrcweir #include <osl/socket.h>
27cdf0e10cSrcweir #include <osl/diagnose.h>
28cdf0e10cSrcweir #include <osl/mutex.h>
29cdf0e10cSrcweir #include <osl/signal.h>
30cdf0e10cSrcweir
31cdf0e10cSrcweir #include <rtl/alloc.h>
32cdf0e10cSrcweir
33cdf0e10cSrcweir #include <ctype.h>
34cdf0e10cSrcweir #include <sal/types.h>
35cdf0e10cSrcweir
36cdf0e10cSrcweir #include "sockimpl.h"
37cdf0e10cSrcweir
38cdf0e10cSrcweir
39cdf0e10cSrcweir /* defines for poll */
40cdf0e10cSrcweir #ifdef HAVE_POLL_H
41cdf0e10cSrcweir #undef HAVE_POLL_H
42cdf0e10cSrcweir #endif
43cdf0e10cSrcweir
44cdf0e10cSrcweir #if defined(LINUX) || defined(NETBSD) || defined ( FREEBSD ) || defined (MACOSX)
45cdf0e10cSrcweir #include <sys/poll.h>
46cdf0e10cSrcweir #define HAVE_POLL_H
47cdf0e10cSrcweir #endif /* HAVE_POLL_H */
48cdf0e10cSrcweir
49cdf0e10cSrcweir #if defined(SOLARIS)
50cdf0e10cSrcweir #include <poll.h>
51cdf0e10cSrcweir #define HAVE_POLL_H
52cdf0e10cSrcweir #endif /* SOLARIS */
53cdf0e10cSrcweir
54cdf0e10cSrcweir #ifndef HAVE_POLL_H
55cdf0e10cSrcweir #define POLLIN 0x0001
56cdf0e10cSrcweir #define POLLOUT 0x0002
57cdf0e10cSrcweir #define POLLPRI 0x0004
58cdf0e10cSrcweir #endif /* HAVE_POLL_H */
59cdf0e10cSrcweir
60cdf0e10cSrcweir
61cdf0e10cSrcweir /* defines for shutdown */
62cdf0e10cSrcweir #define SD_RECEIVE 0
63cdf0e10cSrcweir #define SD_SEND 1
64cdf0e10cSrcweir #define SD_BOTH 2
65cdf0e10cSrcweir
66cdf0e10cSrcweir
67cdf0e10cSrcweir /*
68cdf0e10cSrcweir oslSocketAddr is a pointer to a Berkeley struct sockaddr.
69cdf0e10cSrcweir I refrained from using sockaddr_in because of possible further
70cdf0e10cSrcweir extensions of this socket-interface (IP-NG?).
71cdf0e10cSrcweir The intention was to hide all Berkeley data-structures from
72cdf0e10cSrcweir direct access past the osl-interface.
73cdf0e10cSrcweir
74cdf0e10cSrcweir The current implementation is internet (IP) centered. All
75cdf0e10cSrcweir the constructor-functions (osl_create...) take parameters
76cdf0e10cSrcweir that will probably make sense only in the IP-environment
77cdf0e10cSrcweir (e.g. because of using the dotted-address-format).
78cdf0e10cSrcweir
79cdf0e10cSrcweir If the interface will be extended to host other protocol-
80cdf0e10cSrcweir families, I expect no externally visible changes in the
81cdf0e10cSrcweir existing functions. You'll probably need only new
82cdf0e10cSrcweir constructor-functions who take the different address
83cdf0e10cSrcweir formats into consideration (maybe a long dotted address
84cdf0e10cSrcweir or whatever).
85cdf0e10cSrcweir */
86cdf0e10cSrcweir
87cdf0e10cSrcweir /* _Note_ that I rely on the fact that oslSocketAddr and struct sockaddr */
88cdf0e10cSrcweir /* are the same! I don't like it very much but see no other easy way to */
89cdf0e10cSrcweir /* conceal the struct sockaddr from the eyes of the user. */
90cdf0e10cSrcweir
91cdf0e10cSrcweir
92cdf0e10cSrcweir #define OSL_INVALID_SOCKET -1
93cdf0e10cSrcweir #define OSL_SOCKET_ERROR -1
94cdf0e10cSrcweir
95cdf0e10cSrcweir
96cdf0e10cSrcweir /* Buffer size for gethostbyname */
97cdf0e10cSrcweir #define MAX_HOSTBUFFER_SIZE 2048
98cdf0e10cSrcweir
99cdf0e10cSrcweir /*****************************************************************************/
100cdf0e10cSrcweir /* enum oslAddrFamily */
101cdf0e10cSrcweir /*****************************************************************************/
102cdf0e10cSrcweir
103cdf0e10cSrcweir /* map */
104cdf0e10cSrcweir static unsigned long FamilyMap[]= {
105cdf0e10cSrcweir AF_INET, /* osl_Socket_FamilyInet */
106cdf0e10cSrcweir AF_IPX, /* osl_Socket_FamilyIpx */
107cdf0e10cSrcweir 0 /* osl_Socket_FamilyInvalid */
108cdf0e10cSrcweir };
109cdf0e10cSrcweir
110cdf0e10cSrcweir /* reverse map */
osl_AddrFamilyFromNative(sal_uInt32 nativeType)111cdf0e10cSrcweir static oslAddrFamily osl_AddrFamilyFromNative(sal_uInt32 nativeType)
112cdf0e10cSrcweir {
113cdf0e10cSrcweir oslAddrFamily i= (oslAddrFamily)0;
114cdf0e10cSrcweir
115cdf0e10cSrcweir while(i != osl_Socket_FamilyInvalid)
116cdf0e10cSrcweir {
117cdf0e10cSrcweir if(FamilyMap[i] == nativeType)
118cdf0e10cSrcweir return i;
119cdf0e10cSrcweir i = (oslAddrFamily) ( i + 1 );
120cdf0e10cSrcweir }
121cdf0e10cSrcweir
122cdf0e10cSrcweir return i;
123cdf0e10cSrcweir }
124cdf0e10cSrcweir
125cdf0e10cSrcweir /* macros */
126cdf0e10cSrcweir #define FAMILY_FROM_NATIVE(y) osl_AddrFamilyFromNative(y)
127cdf0e10cSrcweir #define FAMILY_TO_NATIVE(x) (short)FamilyMap[x]
128cdf0e10cSrcweir
129cdf0e10cSrcweir /*****************************************************************************/
130cdf0e10cSrcweir /* enum oslProtocol */
131cdf0e10cSrcweir /*****************************************************************************/
132cdf0e10cSrcweir
133cdf0e10cSrcweir /* map */
134cdf0e10cSrcweir static sal_uInt32 ProtocolMap[]= {
135cdf0e10cSrcweir 0, /* osl_Socket_ProtocolIp */
136cdf0e10cSrcweir NSPROTO_IPX, /* osl_Socket_ProtocolIpx */
137cdf0e10cSrcweir NSPROTO_SPX, /* osl_Socket_ProtocolSpx */
138cdf0e10cSrcweir NSPROTO_SPXII, /* osl_Socket_ProtocolSpxII */
139cdf0e10cSrcweir 0 /* osl_Socket_ProtocolInvalid */
140cdf0e10cSrcweir };
141cdf0e10cSrcweir
142cdf0e10cSrcweir /* reverse map */
143cdf0e10cSrcweir /* mfe: NOT USED
144cdf0e10cSrcweir static oslProtocol osl_ProtocolFromNative(sal_uInt32 nativeType)
145cdf0e10cSrcweir {
146cdf0e10cSrcweir oslProtocol i= (oslProtocol)0;
147cdf0e10cSrcweir
148cdf0e10cSrcweir while(i != osl_Socket_ProtocolInvalid)
149cdf0e10cSrcweir {
150cdf0e10cSrcweir if(ProtocolMap[i] == nativeType)
151cdf0e10cSrcweir return i;
152cdf0e10cSrcweir i = (oslProtocol) ( i + 1);
153cdf0e10cSrcweir }
154cdf0e10cSrcweir
155cdf0e10cSrcweir return i;
156cdf0e10cSrcweir }
157cdf0e10cSrcweir */
158cdf0e10cSrcweir
159cdf0e10cSrcweir /* macros */
160cdf0e10cSrcweir #define PROTOCOL_FROM_NATIVE(y) osl_ProtocolFromNative(y)
161cdf0e10cSrcweir #define PROTOCOL_TO_NATIVE(x) ProtocolMap[x]
162cdf0e10cSrcweir
163cdf0e10cSrcweir
164cdf0e10cSrcweir /*****************************************************************************/
165cdf0e10cSrcweir /* enum oslSocketType */
166cdf0e10cSrcweir /*****************************************************************************/
167cdf0e10cSrcweir
168cdf0e10cSrcweir /* map */
169cdf0e10cSrcweir static sal_uInt32 TypeMap[]= {
170cdf0e10cSrcweir SOCK_STREAM, /* osl_Socket_TypeStream */
171cdf0e10cSrcweir SOCK_DGRAM, /* osl_Socket_TypeDgram */
172cdf0e10cSrcweir SOCK_RAW, /* osl_Socket_TypeRaw */
173cdf0e10cSrcweir SOCK_RDM, /* osl_Socket_TypeRdm */
174cdf0e10cSrcweir SOCK_SEQPACKET, /* osl_Socket_TypeSeqPacket */
175cdf0e10cSrcweir 0 /* osl_Socket_TypeInvalid */
176cdf0e10cSrcweir };
177cdf0e10cSrcweir
178cdf0e10cSrcweir /* reverse map */
osl_SocketTypeFromNative(sal_uInt32 nativeType)179cdf0e10cSrcweir static oslSocketType osl_SocketTypeFromNative(sal_uInt32 nativeType)
180cdf0e10cSrcweir {
181cdf0e10cSrcweir oslSocketType i= (oslSocketType)0;
182cdf0e10cSrcweir
183cdf0e10cSrcweir while(i != osl_Socket_TypeInvalid)
184cdf0e10cSrcweir {
185cdf0e10cSrcweir if(TypeMap[i] == nativeType)
186cdf0e10cSrcweir return i;
187cdf0e10cSrcweir i = (oslSocketType)(i + 1);
188cdf0e10cSrcweir }
189cdf0e10cSrcweir
190cdf0e10cSrcweir return i;
191cdf0e10cSrcweir }
192cdf0e10cSrcweir
193cdf0e10cSrcweir /* macros */
194cdf0e10cSrcweir #define TYPE_TO_NATIVE(x) TypeMap[x]
195cdf0e10cSrcweir #define TYPE_FROM_NATIVE(y) osl_SocketTypeFromNative(y)
196cdf0e10cSrcweir
197cdf0e10cSrcweir
198cdf0e10cSrcweir /*****************************************************************************/
199cdf0e10cSrcweir /* enum oslSocketOption */
200cdf0e10cSrcweir /*****************************************************************************/
201cdf0e10cSrcweir
202cdf0e10cSrcweir /* map */
203cdf0e10cSrcweir static sal_uInt32 OptionMap[]= {
204cdf0e10cSrcweir SO_DEBUG, /* osl_Socket_OptionDebug */
205cdf0e10cSrcweir SO_ACCEPTCONN, /* osl_Socket_OptionAcceptConn */
206cdf0e10cSrcweir SO_REUSEADDR, /* osl_Socket_OptionReuseAddr */
207cdf0e10cSrcweir SO_KEEPALIVE, /* osl_Socket_OptionKeepAlive */
208cdf0e10cSrcweir SO_DONTROUTE, /* osl_Socket_OptionDontRoute */
209cdf0e10cSrcweir SO_BROADCAST, /* osl_Socket_OptionBroadcast */
210cdf0e10cSrcweir SO_USELOOPBACK, /* osl_Socket_OptionUseLoopback */
211cdf0e10cSrcweir SO_LINGER, /* osl_Socket_OptionLinger */
212cdf0e10cSrcweir SO_OOBINLINE, /* osl_Socket_OptionOOBinLine */
213cdf0e10cSrcweir SO_SNDBUF, /* osl_Socket_OptionSndBuf */
214cdf0e10cSrcweir SO_RCVBUF, /* osl_Socket_OptionRcvBuf */
215cdf0e10cSrcweir SO_SNDLOWAT, /* osl_Socket_OptionSndLowat */
216cdf0e10cSrcweir SO_RCVLOWAT, /* osl_Socket_OptionRcvLowat */
217cdf0e10cSrcweir SO_SNDTIMEO, /* osl_Socket_OptionSndTimeo */
218cdf0e10cSrcweir SO_RCVTIMEO, /* osl_Socket_OptionRcvTimeo */
219cdf0e10cSrcweir SO_ERROR, /* osl_Socket_OptionError */
220cdf0e10cSrcweir SO_TYPE, /* osl_Socket_OptionType */
221cdf0e10cSrcweir TCP_NODELAY, /* osl_Socket_OptionTcpNoDelay */
222cdf0e10cSrcweir 0 /* osl_Socket_OptionInvalid */
223cdf0e10cSrcweir };
224cdf0e10cSrcweir
225cdf0e10cSrcweir /* reverse map */
226cdf0e10cSrcweir /* mfe: NOT USED
227cdf0e10cSrcweir static oslSocketOption osl_SocketOptionFromNative(sal_uInt32 nativeType)
228cdf0e10cSrcweir {
229cdf0e10cSrcweir oslSocketOption i= (oslSocketOption)0;
230cdf0e10cSrcweir
231cdf0e10cSrcweir while(i != osl_Socket_OptionInvalid)
232cdf0e10cSrcweir {
233cdf0e10cSrcweir if(OptionMap[i] == nativeType)
234cdf0e10cSrcweir return i;
235cdf0e10cSrcweir i = (oslSocketOption) ( i + 1 );
236cdf0e10cSrcweir }
237cdf0e10cSrcweir
238cdf0e10cSrcweir return i;
239cdf0e10cSrcweir }
240cdf0e10cSrcweir */
241cdf0e10cSrcweir /* macros */
242cdf0e10cSrcweir #define OPTION_TO_NATIVE(x) OptionMap[x]
243cdf0e10cSrcweir #define OPTION_FROM_NATIVE(y) osl_SocketOptionFromNative(y)
244cdf0e10cSrcweir
245cdf0e10cSrcweir
246cdf0e10cSrcweir /*****************************************************************************/
247cdf0e10cSrcweir /* enum oslSocketOptionLevel */
248cdf0e10cSrcweir /*****************************************************************************/
249cdf0e10cSrcweir
250cdf0e10cSrcweir static sal_uInt32 OptionLevelMap[]= {
251cdf0e10cSrcweir SOL_SOCKET, /* osl_Socket_LevelSocket */
252cdf0e10cSrcweir IPPROTO_TCP, /* osl_Socket_LevelTcp */
253cdf0e10cSrcweir 0 /* osl_Socket_LevelInvalid */
254cdf0e10cSrcweir };
255cdf0e10cSrcweir
256cdf0e10cSrcweir /* reverse map */
257cdf0e10cSrcweir /* mfe: NOT USED
258cdf0e10cSrcweir static oslSocketOptionLevel osl_SocketOptionLevelFromNative(sal_uInt32 nativeType)
259cdf0e10cSrcweir {
260cdf0e10cSrcweir oslSocketOptionLevel i= (oslSocketOptionLevel)0;
261cdf0e10cSrcweir
262cdf0e10cSrcweir while(i != osl_Socket_LevelInvalid)
263cdf0e10cSrcweir {
264cdf0e10cSrcweir if(OptionLevelMap[i] == nativeType)
265cdf0e10cSrcweir return i;
266cdf0e10cSrcweir i = (oslSocketOptionLevel) ( i + 1 );
267cdf0e10cSrcweir }
268cdf0e10cSrcweir
269cdf0e10cSrcweir return i;
270cdf0e10cSrcweir }
271cdf0e10cSrcweir */
272cdf0e10cSrcweir /* macros */
273cdf0e10cSrcweir #define OPTION_LEVEL_TO_NATIVE(x) OptionLevelMap[x]
274cdf0e10cSrcweir #define OPTION_LEVEL_FROM_NATIVE(y) osl_SocketOptionLevelFromNative(y)
275cdf0e10cSrcweir
276cdf0e10cSrcweir /*****************************************************************************/
277cdf0e10cSrcweir /* enum oslSocketMsgFlag */
278cdf0e10cSrcweir /*****************************************************************************/
279cdf0e10cSrcweir
280cdf0e10cSrcweir static sal_uInt32 SocketMsgFlagMap[]= {
281cdf0e10cSrcweir 0, /* osl_Socket_MsgNormal */
282cdf0e10cSrcweir MSG_OOB, /* osl_Socket_MsgOOB */
283cdf0e10cSrcweir MSG_PEEK, /* osl_Socket_MsgPeek */
284cdf0e10cSrcweir MSG_DONTROUTE, /* osl_Socket_MsgDontRoute */
285cdf0e10cSrcweir MSG_MAXIOVLEN, /* osl_Socket_MsgMaxIOVLen */
286cdf0e10cSrcweir 0 /* osl_Socket_MsgInvalid */
287cdf0e10cSrcweir };
288cdf0e10cSrcweir
289cdf0e10cSrcweir /* reverse map */
290cdf0e10cSrcweir /* mfe: NOT USED
291cdf0e10cSrcweir static oslSocketMsgFlag osl_SocketMsgFlagFromNative(sal_uInt32 nativeType)
292cdf0e10cSrcweir {
293cdf0e10cSrcweir oslSocketMsgFlag i= (oslSocketMsgFlag)0;
294cdf0e10cSrcweir
295cdf0e10cSrcweir while(i != osl_Socket_MsgInvalid)
296cdf0e10cSrcweir {
297cdf0e10cSrcweir if(SocketMsgFlagMap[i] == nativeType)
298cdf0e10cSrcweir return i;
299cdf0e10cSrcweir i = (oslSocketMsgFlag) ( i + 1 );
300cdf0e10cSrcweir }
301cdf0e10cSrcweir
302cdf0e10cSrcweir return i;
303cdf0e10cSrcweir }
304cdf0e10cSrcweir */
305cdf0e10cSrcweir
306cdf0e10cSrcweir /* macros */
307cdf0e10cSrcweir #define MSG_FLAG_TO_NATIVE(x) SocketMsgFlagMap[x]
308cdf0e10cSrcweir #define MSG_FLAG_FROM_NATIVE(y) osl_SocketMsgFlagFromNative(y)
309cdf0e10cSrcweir
310cdf0e10cSrcweir
311cdf0e10cSrcweir /*****************************************************************************/
312cdf0e10cSrcweir /* enum oslSocketDirection */
313cdf0e10cSrcweir /*****************************************************************************/
314cdf0e10cSrcweir
315cdf0e10cSrcweir static sal_uInt32 SocketDirection[]= {
316cdf0e10cSrcweir SD_RECEIVE, /* osl_Socket_DirRead */
317cdf0e10cSrcweir SD_SEND, /* osl_Socket_DirWrite */
318cdf0e10cSrcweir SD_BOTH, /* osl_Socket_DirReadWrite */
319cdf0e10cSrcweir 0 /* osl_Socket_DirInvalid */
320cdf0e10cSrcweir };
321cdf0e10cSrcweir
322cdf0e10cSrcweir /* reverse map */
323cdf0e10cSrcweir /* mfe: NOT USED
324cdf0e10cSrcweir static oslSocketDirection osl_SocketDirectionFromNative(sal_uInt32 nativeType)
325cdf0e10cSrcweir {
326cdf0e10cSrcweir oslSocketDirection i= (oslSocketDirection)0;
327cdf0e10cSrcweir
328cdf0e10cSrcweir while(i != osl_Socket_DirInvalid)
329cdf0e10cSrcweir {
330cdf0e10cSrcweir if(SocketDirection[i] == nativeType)
331cdf0e10cSrcweir return i;
332cdf0e10cSrcweir i = (oslSocketDirection) ( i + 1 );
333cdf0e10cSrcweir }
334cdf0e10cSrcweir
335cdf0e10cSrcweir return i;
336cdf0e10cSrcweir }
337cdf0e10cSrcweir */
338cdf0e10cSrcweir
339cdf0e10cSrcweir /* macros */
340cdf0e10cSrcweir #define DIRECTION_TO_NATIVE(x) SocketDirection[x]
341cdf0e10cSrcweir #define DIRECTION_FROM_NATIVE(y) osl_SocketDirectionFromNative(y)
342cdf0e10cSrcweir
343cdf0e10cSrcweir /*****************************************************************************/
344cdf0e10cSrcweir /* enum oslSocketError */
345cdf0e10cSrcweir /*****************************************************************************/
346cdf0e10cSrcweir
347cdf0e10cSrcweir static struct
348cdf0e10cSrcweir {
349cdf0e10cSrcweir int errcode;
350cdf0e10cSrcweir oslSocketError error;
351cdf0e10cSrcweir } SocketError[]= {
352cdf0e10cSrcweir { 0, osl_Socket_E_None }, /* no error */
353cdf0e10cSrcweir { ENOTSOCK, osl_Socket_E_NotSocket }, /* Socket operation on non-socket */
354cdf0e10cSrcweir { EDESTADDRREQ, osl_Socket_E_DestAddrReq }, /* Destination address required */
355cdf0e10cSrcweir { EMSGSIZE, osl_Socket_E_MsgSize }, /* Message too long */
356cdf0e10cSrcweir { EPROTOTYPE, osl_Socket_E_Prototype }, /* Protocol wrong type for socket */
357cdf0e10cSrcweir { ENOPROTOOPT, osl_Socket_E_NoProtocol }, /* Protocol not available */
358cdf0e10cSrcweir { EPROTONOSUPPORT, osl_Socket_E_ProtocolNoSupport }, /* Protocol not supported */
359cdf0e10cSrcweir { ESOCKTNOSUPPORT, osl_Socket_E_TypeNoSupport }, /* Socket type not supported */
360cdf0e10cSrcweir { EOPNOTSUPP, osl_Socket_E_OpNotSupport }, /* Operation not supported on socket */
361cdf0e10cSrcweir { EPFNOSUPPORT, osl_Socket_E_PfNoSupport }, /* Protocol family not supported */
362cdf0e10cSrcweir { EAFNOSUPPORT, osl_Socket_E_AfNoSupport }, /* Address family not supported by */
363cdf0e10cSrcweir /* protocol family */
364cdf0e10cSrcweir { EADDRINUSE, osl_Socket_E_AddrInUse }, /* Address already in use */
365cdf0e10cSrcweir { EADDRNOTAVAIL, osl_Socket_E_AddrNotAvail }, /* Can't assign requested address */
366cdf0e10cSrcweir { ENETDOWN, osl_Socket_E_NetDown }, /* Network is down */
367cdf0e10cSrcweir { ENETUNREACH, osl_Socket_E_NetUnreachable }, /* Network is unreachable */
368cdf0e10cSrcweir { ENETRESET, osl_Socket_E_NetReset }, /* Network dropped connection because */
369cdf0e10cSrcweir /* of reset */
370cdf0e10cSrcweir { ECONNABORTED, osl_Socket_E_ConnAborted }, /* Software caused connection abort */
371cdf0e10cSrcweir { ECONNRESET, osl_Socket_E_ConnReset }, /* Connection reset by peer */
372cdf0e10cSrcweir { ENOBUFS, osl_Socket_E_NoBufferSpace }, /* No buffer space available */
373cdf0e10cSrcweir { EISCONN, osl_Socket_E_IsConnected }, /* Socket is already connected */
374cdf0e10cSrcweir { ENOTCONN, osl_Socket_E_NotConnected }, /* Socket is not connected */
375cdf0e10cSrcweir { ESHUTDOWN, osl_Socket_E_Shutdown }, /* Can't send after socket shutdown */
376cdf0e10cSrcweir { ETOOMANYREFS, osl_Socket_E_TooManyRefs }, /* Too many references: can't splice */
377cdf0e10cSrcweir { ETIMEDOUT, osl_Socket_E_TimedOut }, /* Connection timed out */
378cdf0e10cSrcweir { ECONNREFUSED, osl_Socket_E_ConnRefused }, /* Connection refused */
379cdf0e10cSrcweir { EHOSTDOWN, osl_Socket_E_HostDown }, /* Host is down */
380cdf0e10cSrcweir { EHOSTUNREACH, osl_Socket_E_HostUnreachable }, /* No route to host */
381cdf0e10cSrcweir { EWOULDBLOCK, osl_Socket_E_WouldBlock }, /* call would block on non-blocking socket */
382cdf0e10cSrcweir { EALREADY, osl_Socket_E_Already }, /* operation already in progress */
383cdf0e10cSrcweir { EINPROGRESS, osl_Socket_E_InProgress }, /* operation now in progress */
384cdf0e10cSrcweir { EAGAIN, osl_Socket_E_WouldBlock }, /* same as EWOULDBLOCK */
385cdf0e10cSrcweir { -1, osl_Socket_E_InvalidError }
386cdf0e10cSrcweir };
387cdf0e10cSrcweir
388cdf0e10cSrcweir /* map */
389cdf0e10cSrcweir /* mfe: NOT USED
390cdf0e10cSrcweir static int osl_NativeFromSocketError(oslSocketError errorCode)
391cdf0e10cSrcweir {
392cdf0e10cSrcweir int i = 0;
393cdf0e10cSrcweir
394cdf0e10cSrcweir while ((SocketError[i].error != osl_Socket_E_InvalidError) &&
395cdf0e10cSrcweir (SocketError[i].error != errorCode)) i++;
396cdf0e10cSrcweir
397cdf0e10cSrcweir return SocketError[i].errcode;
398cdf0e10cSrcweir }
399cdf0e10cSrcweir */
400cdf0e10cSrcweir
401cdf0e10cSrcweir /* reverse map */
osl_SocketErrorFromNative(int nativeType)402cdf0e10cSrcweir static oslSocketError osl_SocketErrorFromNative(int nativeType)
403cdf0e10cSrcweir {
404cdf0e10cSrcweir int i = 0;
405cdf0e10cSrcweir
406cdf0e10cSrcweir while ((SocketError[i].error != osl_Socket_E_InvalidError) &&
407cdf0e10cSrcweir (SocketError[i].errcode != nativeType)) i++;
408cdf0e10cSrcweir
409cdf0e10cSrcweir return SocketError[i].error;
410cdf0e10cSrcweir }
411cdf0e10cSrcweir
412cdf0e10cSrcweir /* macros */
413cdf0e10cSrcweir #define ERROR_TO_NATIVE(x) osl_NativeFromSocketError(x)
414cdf0e10cSrcweir #define ERROR_FROM_NATIVE(y) osl_SocketErrorFromNative(y)
415cdf0e10cSrcweir
416cdf0e10cSrcweir /*****************************************************************************/
417cdf0e10cSrcweir /* local function prototypes */
418cdf0e10cSrcweir /*****************************************************************************/
419cdf0e10cSrcweir
420cdf0e10cSrcweir oslSocketAddr SAL_CALL osl_psz_createInetSocketAddr (
421cdf0e10cSrcweir const sal_Char* pszDottedAddr, sal_Int32 Port);
422cdf0e10cSrcweir
423cdf0e10cSrcweir oslSocketAddr SAL_CALL osl_psz_createIpxSocketAddr (
424cdf0e10cSrcweir const sal_Char NetNumber[4],
425cdf0e10cSrcweir const sal_Char NodeNumber[6],
426cdf0e10cSrcweir sal_uInt32 SocketNumber);
427cdf0e10cSrcweir
428cdf0e10cSrcweir oslHostAddr SAL_CALL osl_psz_createHostAddr (
429cdf0e10cSrcweir const sal_Char *pszHostname, const oslSocketAddr Addr);
430cdf0e10cSrcweir
431cdf0e10cSrcweir oslHostAddr SAL_CALL osl_psz_createHostAddrByName (
432cdf0e10cSrcweir const sal_Char *pszHostname);
433cdf0e10cSrcweir
434cdf0e10cSrcweir const sal_Char* SAL_CALL osl_psz_getHostnameOfHostAddr (
435cdf0e10cSrcweir const oslHostAddr Addr);
436cdf0e10cSrcweir
437cdf0e10cSrcweir oslSocketResult SAL_CALL osl_psz_getLocalHostname (
438cdf0e10cSrcweir sal_Char *pBuffer, sal_uInt32 nBufLen);
439cdf0e10cSrcweir
440cdf0e10cSrcweir oslSocketAddr SAL_CALL osl_psz_resolveHostname (
441cdf0e10cSrcweir const sal_Char* pszHostname);
442cdf0e10cSrcweir
443cdf0e10cSrcweir sal_Int32 SAL_CALL osl_psz_getServicePort (
444cdf0e10cSrcweir const sal_Char* pszServicename, const sal_Char* pszProtocol);
445cdf0e10cSrcweir
446cdf0e10cSrcweir oslSocketResult SAL_CALL osl_psz_getHostnameOfSocketAddr (
447cdf0e10cSrcweir oslSocketAddr Addr, sal_Char *pBuffer, sal_uInt32 BufferSize);
448cdf0e10cSrcweir
449cdf0e10cSrcweir oslSocketResult SAL_CALL osl_psz_getDottedInetAddrOfSocketAddr (
450cdf0e10cSrcweir oslSocketAddr Addr, sal_Char *pBuffer, sal_uInt32 BufferSize);
451cdf0e10cSrcweir
452cdf0e10cSrcweir void SAL_CALL osl_psz_getLastSocketErrorDescription (
453cdf0e10cSrcweir oslSocket Socket, sal_Char* pBuffer, sal_uInt32 BufferSize);
454cdf0e10cSrcweir
455cdf0e10cSrcweir /*****************************************************************************/
456cdf0e10cSrcweir /* osl_create/destroy-SocketImpl */
457cdf0e10cSrcweir /*****************************************************************************/
458cdf0e10cSrcweir
459cdf0e10cSrcweir #if OSL_DEBUG_LEVEL > 1
460cdf0e10cSrcweir static sal_uInt32 g_nSocketImpl = 0;
461cdf0e10cSrcweir static sal_uInt32 g_nSocketAddr = 0;
462cdf0e10cSrcweir
463cdf0e10cSrcweir /* sorry, must be implemented otherwise */
464cdf0e10cSrcweir #if 0
465cdf0e10cSrcweir struct LeakWarning
466cdf0e10cSrcweir {
467cdf0e10cSrcweir ~LeakWarning()
468cdf0e10cSrcweir {
469cdf0e10cSrcweir if( g_nSocketImpl )
470cdf0e10cSrcweir OSL_TRACE( "sal_socket: %d socket instances leak\n" , g_nSocketImpl );
471cdf0e10cSrcweir if( g_nSocketAddr )
472cdf0e10cSrcweir OSL_TRACE( "sal_socket: %d socket address instances leak\n" , g_nSocketAddr );
473cdf0e10cSrcweir }
474cdf0e10cSrcweir };
475cdf0e10cSrcweir LeakWarning socketWarning;
476cdf0e10cSrcweir #endif
477cdf0e10cSrcweir
478cdf0e10cSrcweir #endif /* OSL_DEBUG_LEVEL */
479cdf0e10cSrcweir
480cdf0e10cSrcweir
__osl_createSocketImpl(int Socket)481cdf0e10cSrcweir oslSocket __osl_createSocketImpl(int Socket)
482cdf0e10cSrcweir {
483cdf0e10cSrcweir oslSocket pSocket;
484cdf0e10cSrcweir
485cdf0e10cSrcweir pSocket = (oslSocket)calloc(1, sizeof(struct oslSocketImpl));
486cdf0e10cSrcweir
487cdf0e10cSrcweir pSocket->m_Socket = Socket;
488cdf0e10cSrcweir pSocket->m_nLastError = 0;
489cdf0e10cSrcweir pSocket->m_CloseCallback = 0;
490cdf0e10cSrcweir pSocket->m_CallbackArg = 0;
491cdf0e10cSrcweir pSocket->m_nRefCount = 1;
492cdf0e10cSrcweir
493cdf0e10cSrcweir #if defined(LINUX)
494cdf0e10cSrcweir pSocket->m_bIsAccepting = sal_False;
495cdf0e10cSrcweir #endif
496cdf0e10cSrcweir
497cdf0e10cSrcweir #if OSL_DEBUG_LEVEL > 1
498cdf0e10cSrcweir g_nSocketImpl ++;
499cdf0e10cSrcweir #endif
500cdf0e10cSrcweir return pSocket;
501cdf0e10cSrcweir }
502cdf0e10cSrcweir
__osl_destroySocketImpl(oslSocket Socket)503cdf0e10cSrcweir void __osl_destroySocketImpl(oslSocket Socket)
504cdf0e10cSrcweir {
505cdf0e10cSrcweir if ( Socket != NULL)
506cdf0e10cSrcweir free((struct oslSocketImpl *) Socket);
507cdf0e10cSrcweir #if OSL_DEBUG_LEVEL > 1
508cdf0e10cSrcweir g_nSocketImpl --;
509cdf0e10cSrcweir #endif
510cdf0e10cSrcweir }
511cdf0e10cSrcweir
__osl_createSocketAddr()512cdf0e10cSrcweir static oslSocketAddr __osl_createSocketAddr( )
513cdf0e10cSrcweir {
514cdf0e10cSrcweir oslSocketAddr pAddr = (oslSocketAddr) rtl_allocateZeroMemory( sizeof( struct oslSocketAddrImpl ));
515cdf0e10cSrcweir #if OSL_DEBUG_LEVEL > 1
516cdf0e10cSrcweir g_nSocketAddr ++;
517cdf0e10cSrcweir #endif
518cdf0e10cSrcweir return pAddr;
519cdf0e10cSrcweir }
520cdf0e10cSrcweir
__osl_createSocketAddrWithFamily(oslAddrFamily family,sal_Int32 port,sal_uInt32 nAddr)521cdf0e10cSrcweir static oslSocketAddr __osl_createSocketAddrWithFamily(
522cdf0e10cSrcweir oslAddrFamily family, sal_Int32 port, sal_uInt32 nAddr )
523cdf0e10cSrcweir {
524cdf0e10cSrcweir oslSocketAddr pAddr;
525cdf0e10cSrcweir
526cdf0e10cSrcweir OSL_ASSERT( family == osl_Socket_FamilyInet );
527cdf0e10cSrcweir
528cdf0e10cSrcweir pAddr = __osl_createSocketAddr();
529cdf0e10cSrcweir switch( family )
530cdf0e10cSrcweir {
531cdf0e10cSrcweir case osl_Socket_FamilyInet:
532cdf0e10cSrcweir {
533cdf0e10cSrcweir struct sockaddr_in* pInetAddr= (struct sockaddr_in*)&(pAddr->m_sockaddr);
534cdf0e10cSrcweir
535cdf0e10cSrcweir pInetAddr->sin_family = FAMILY_TO_NATIVE(osl_Socket_FamilyInet);
536cdf0e10cSrcweir pInetAddr->sin_addr.s_addr = nAddr;
537cdf0e10cSrcweir pInetAddr->sin_port = (sal_uInt16)(port&0xffff);
538cdf0e10cSrcweir break;
539cdf0e10cSrcweir }
540cdf0e10cSrcweir default:
541cdf0e10cSrcweir pAddr->m_sockaddr.sa_family = FAMILY_TO_NATIVE(family);
542cdf0e10cSrcweir }
543cdf0e10cSrcweir return pAddr;
544cdf0e10cSrcweir }
545cdf0e10cSrcweir
__osl_createSocketAddrFromSystem(struct sockaddr * pSystemSockAddr)546cdf0e10cSrcweir static oslSocketAddr __osl_createSocketAddrFromSystem( struct sockaddr *pSystemSockAddr )
547cdf0e10cSrcweir {
548cdf0e10cSrcweir oslSocketAddr pAddr = __osl_createSocketAddr();
549cdf0e10cSrcweir memcpy( &(pAddr->m_sockaddr), pSystemSockAddr, sizeof( struct sockaddr ) );
550cdf0e10cSrcweir return pAddr;
551cdf0e10cSrcweir }
552cdf0e10cSrcweir
__osl_destroySocketAddr(oslSocketAddr addr)553cdf0e10cSrcweir static void __osl_destroySocketAddr( oslSocketAddr addr )
554cdf0e10cSrcweir {
555cdf0e10cSrcweir #if OSL_DEBUG_LEVEL > 1
556cdf0e10cSrcweir g_nSocketAddr --;
557cdf0e10cSrcweir #endif
558cdf0e10cSrcweir rtl_freeMemory( addr );
559cdf0e10cSrcweir }
560cdf0e10cSrcweir
561cdf0e10cSrcweir /*****************************************************************************/
562cdf0e10cSrcweir /* osl_createEmptySocketAddr */
563cdf0e10cSrcweir /*****************************************************************************/
osl_createEmptySocketAddr(oslAddrFamily Family)564cdf0e10cSrcweir oslSocketAddr SAL_CALL osl_createEmptySocketAddr(oslAddrFamily Family)
565cdf0e10cSrcweir {
566cdf0e10cSrcweir oslSocketAddr pAddr = 0;
567cdf0e10cSrcweir
568cdf0e10cSrcweir /* is it an internet-Addr? */
569cdf0e10cSrcweir if (Family == osl_Socket_FamilyInet)
570cdf0e10cSrcweir {
571cdf0e10cSrcweir pAddr = __osl_createSocketAddrWithFamily(Family, 0 , htonl(INADDR_ANY) );
572cdf0e10cSrcweir }
573cdf0e10cSrcweir else
574cdf0e10cSrcweir {
575cdf0e10cSrcweir pAddr = __osl_createSocketAddrWithFamily( Family , 0 , 0 );
576cdf0e10cSrcweir }
577cdf0e10cSrcweir
578cdf0e10cSrcweir return pAddr;
579cdf0e10cSrcweir }
580cdf0e10cSrcweir
581cdf0e10cSrcweir /*****************************************************************************/
582cdf0e10cSrcweir /* osl_copySocketAddr */
583cdf0e10cSrcweir /*****************************************************************************/
osl_copySocketAddr(oslSocketAddr Addr)584cdf0e10cSrcweir oslSocketAddr SAL_CALL osl_copySocketAddr(oslSocketAddr Addr)
585cdf0e10cSrcweir {
586cdf0e10cSrcweir oslSocketAddr pCopy = 0;
587cdf0e10cSrcweir if (Addr)
588cdf0e10cSrcweir {
589cdf0e10cSrcweir pCopy = __osl_createSocketAddr();
590cdf0e10cSrcweir
591cdf0e10cSrcweir if (pCopy)
592cdf0e10cSrcweir memcpy(&(pCopy->m_sockaddr),&(Addr->m_sockaddr), sizeof(struct sockaddr));
593cdf0e10cSrcweir }
594cdf0e10cSrcweir return pCopy;
595cdf0e10cSrcweir }
596cdf0e10cSrcweir
597cdf0e10cSrcweir /*****************************************************************************/
598cdf0e10cSrcweir /* osl_isEqualSocketAddr */
599cdf0e10cSrcweir /*****************************************************************************/
osl_isEqualSocketAddr(oslSocketAddr Addr1,oslSocketAddr Addr2)600cdf0e10cSrcweir sal_Bool SAL_CALL osl_isEqualSocketAddr (
601cdf0e10cSrcweir oslSocketAddr Addr1,
602cdf0e10cSrcweir oslSocketAddr Addr2)
603cdf0e10cSrcweir {
604cdf0e10cSrcweir struct sockaddr* pAddr1= &(Addr1->m_sockaddr);
605cdf0e10cSrcweir struct sockaddr* pAddr2= &(Addr2->m_sockaddr);
606cdf0e10cSrcweir
607cdf0e10cSrcweir OSL_ASSERT(pAddr1);
608cdf0e10cSrcweir OSL_ASSERT(pAddr2);
609cdf0e10cSrcweir
610cdf0e10cSrcweir if (pAddr1->sa_family == pAddr2->sa_family)
611cdf0e10cSrcweir {
612cdf0e10cSrcweir switch (pAddr1->sa_family)
613cdf0e10cSrcweir {
614cdf0e10cSrcweir case AF_INET:
615cdf0e10cSrcweir {
616cdf0e10cSrcweir struct sockaddr_in* pInetAddr1= (struct sockaddr_in*)pAddr1;
617cdf0e10cSrcweir struct sockaddr_in* pInetAddr2= (struct sockaddr_in*)pAddr2;
618cdf0e10cSrcweir
619cdf0e10cSrcweir if ((pInetAddr1->sin_family == pInetAddr2->sin_family) &&
620cdf0e10cSrcweir (pInetAddr1->sin_addr.s_addr == pInetAddr2->sin_addr.s_addr) &&
621cdf0e10cSrcweir (pInetAddr1->sin_port == pInetAddr2->sin_port))
622cdf0e10cSrcweir return (sal_True);
623cdf0e10cSrcweir }
624cdf0e10cSrcweir
625cdf0e10cSrcweir default:
626cdf0e10cSrcweir {
627cdf0e10cSrcweir return (memcmp(pAddr1, Addr2, sizeof(struct sockaddr)) == 0);
628cdf0e10cSrcweir }
629cdf0e10cSrcweir }
630cdf0e10cSrcweir }
631cdf0e10cSrcweir
632cdf0e10cSrcweir return (sal_False);
633cdf0e10cSrcweir }
634cdf0e10cSrcweir
635cdf0e10cSrcweir /*****************************************************************************/
636cdf0e10cSrcweir /* osl_createInetBroadcastAddr */
637cdf0e10cSrcweir /*****************************************************************************/
osl_createInetBroadcastAddr(rtl_uString * strDottedAddr,sal_Int32 Port)638cdf0e10cSrcweir oslSocketAddr SAL_CALL osl_createInetBroadcastAddr (
639cdf0e10cSrcweir rtl_uString *strDottedAddr,
640cdf0e10cSrcweir sal_Int32 Port)
641cdf0e10cSrcweir {
642cdf0e10cSrcweir sal_uInt32 nAddr = OSL_INADDR_NONE;
643cdf0e10cSrcweir oslSocketAddr pAddr;
644cdf0e10cSrcweir
645cdf0e10cSrcweir if (strDottedAddr && strDottedAddr->length)
646cdf0e10cSrcweir {
647cdf0e10cSrcweir /* Dotted host address for limited broadcast */
648cdf0e10cSrcweir rtl_String *pDottedAddr = NULL;
649cdf0e10cSrcweir
650cdf0e10cSrcweir rtl_uString2String (
651cdf0e10cSrcweir &pDottedAddr, strDottedAddr->buffer, strDottedAddr->length,
652cdf0e10cSrcweir RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS);
653cdf0e10cSrcweir
654cdf0e10cSrcweir nAddr = inet_addr (pDottedAddr->buffer);
655cdf0e10cSrcweir rtl_string_release (pDottedAddr);
656cdf0e10cSrcweir }
657cdf0e10cSrcweir
658cdf0e10cSrcweir if (nAddr != OSL_INADDR_NONE)
659cdf0e10cSrcweir {
660cdf0e10cSrcweir /* Limited broadcast */
661cdf0e10cSrcweir nAddr = ntohl(nAddr);
662cdf0e10cSrcweir if (IN_CLASSA(nAddr))
663cdf0e10cSrcweir {
664cdf0e10cSrcweir nAddr &= IN_CLASSA_NET;
665cdf0e10cSrcweir nAddr |= IN_CLASSA_HOST;
666cdf0e10cSrcweir }
667cdf0e10cSrcweir else if (IN_CLASSB(nAddr))
668cdf0e10cSrcweir {
669cdf0e10cSrcweir nAddr &= IN_CLASSB_NET;
670cdf0e10cSrcweir nAddr |= IN_CLASSB_HOST;
671cdf0e10cSrcweir }
672cdf0e10cSrcweir else if (IN_CLASSC(nAddr))
673cdf0e10cSrcweir {
674cdf0e10cSrcweir nAddr &= IN_CLASSC_NET;
675cdf0e10cSrcweir nAddr |= IN_CLASSC_HOST;
676cdf0e10cSrcweir }
677cdf0e10cSrcweir else
678cdf0e10cSrcweir {
679cdf0e10cSrcweir /* No broadcast in class D */
680cdf0e10cSrcweir return ((oslSocketAddr)NULL);
681cdf0e10cSrcweir }
682cdf0e10cSrcweir nAddr = htonl(nAddr);
683cdf0e10cSrcweir }
684cdf0e10cSrcweir
685cdf0e10cSrcweir pAddr = __osl_createSocketAddrWithFamily( osl_Socket_FamilyInet, htons(Port), nAddr );
686cdf0e10cSrcweir return pAddr;
687cdf0e10cSrcweir }
688cdf0e10cSrcweir
689cdf0e10cSrcweir /*****************************************************************************/
690cdf0e10cSrcweir /* osl_createInetSocketAddr */
691cdf0e10cSrcweir /*****************************************************************************/
osl_createInetSocketAddr(rtl_uString * ustrDottedAddr,sal_Int32 Port)692cdf0e10cSrcweir oslSocketAddr SAL_CALL osl_createInetSocketAddr (
693cdf0e10cSrcweir rtl_uString *ustrDottedAddr,
694cdf0e10cSrcweir sal_Int32 Port)
695cdf0e10cSrcweir {
696cdf0e10cSrcweir rtl_String* strDottedAddr=0;
697cdf0e10cSrcweir oslSocketAddr Addr;
698cdf0e10cSrcweir sal_Char* pszDottedAddr=0;
699cdf0e10cSrcweir
700cdf0e10cSrcweir if ( ustrDottedAddr != 0 )
701cdf0e10cSrcweir {
702cdf0e10cSrcweir rtl_uString2String( &strDottedAddr,
703cdf0e10cSrcweir rtl_uString_getStr(ustrDottedAddr),
704cdf0e10cSrcweir rtl_uString_getLength(ustrDottedAddr),
705cdf0e10cSrcweir RTL_TEXTENCODING_UTF8,
706cdf0e10cSrcweir OUSTRING_TO_OSTRING_CVTFLAGS);
707cdf0e10cSrcweir pszDottedAddr = rtl_string_getStr(strDottedAddr);
708cdf0e10cSrcweir }
709cdf0e10cSrcweir
710cdf0e10cSrcweir
711cdf0e10cSrcweir Addr = osl_psz_createInetSocketAddr(pszDottedAddr, Port);
712cdf0e10cSrcweir
713cdf0e10cSrcweir if ( strDottedAddr != 0 )
714cdf0e10cSrcweir {
715cdf0e10cSrcweir rtl_string_release(strDottedAddr);
716cdf0e10cSrcweir }
717cdf0e10cSrcweir
718cdf0e10cSrcweir return Addr;
719cdf0e10cSrcweir }
720cdf0e10cSrcweir
osl_psz_createInetSocketAddr(const sal_Char * pszDottedAddr,sal_Int32 Port)721cdf0e10cSrcweir oslSocketAddr SAL_CALL osl_psz_createInetSocketAddr (
722cdf0e10cSrcweir const sal_Char* pszDottedAddr,
723cdf0e10cSrcweir sal_Int32 Port)
724cdf0e10cSrcweir {
725cdf0e10cSrcweir oslSocketAddr pAddr = 0;
726cdf0e10cSrcweir sal_Int32 Addr = inet_addr(pszDottedAddr);
727cdf0e10cSrcweir if(Addr != -1)
728cdf0e10cSrcweir {
729cdf0e10cSrcweir /* valid dotted addr */
730cdf0e10cSrcweir pAddr = __osl_createSocketAddrWithFamily( osl_Socket_FamilyInet, htons(Port) , Addr );
731cdf0e10cSrcweir }
732cdf0e10cSrcweir return pAddr;
733cdf0e10cSrcweir }
734cdf0e10cSrcweir
735cdf0e10cSrcweir /*****************************************************************************/
736cdf0e10cSrcweir /* osl_setAddrOfSocketAddr */
737cdf0e10cSrcweir /*****************************************************************************/
osl_setAddrOfSocketAddr(oslSocketAddr pAddr,sal_Sequence * pByteSeq)738cdf0e10cSrcweir oslSocketResult SAL_CALL osl_setAddrOfSocketAddr( oslSocketAddr pAddr, sal_Sequence *pByteSeq )
739cdf0e10cSrcweir {
740cdf0e10cSrcweir oslSocketResult res = osl_Socket_Error;
741cdf0e10cSrcweir
742cdf0e10cSrcweir OSL_ASSERT( pAddr );
743cdf0e10cSrcweir OSL_ASSERT( pByteSeq );
744cdf0e10cSrcweir
745cdf0e10cSrcweir if( pAddr && pByteSeq )
746cdf0e10cSrcweir {
747cdf0e10cSrcweir struct sockaddr_in * pSystemInetAddr;
748cdf0e10cSrcweir
749cdf0e10cSrcweir OSL_ASSERT( pAddr->m_sockaddr.sa_family == FAMILY_TO_NATIVE( osl_Socket_FamilyInet ) );
750cdf0e10cSrcweir OSL_ASSERT( pByteSeq->nElements == 4 );
751cdf0e10cSrcweir
752cdf0e10cSrcweir pSystemInetAddr = (struct sockaddr_in * ) &(pAddr->m_sockaddr);
753cdf0e10cSrcweir memcpy( &(pSystemInetAddr->sin_addr) , pByteSeq->elements , 4 );
754cdf0e10cSrcweir res = osl_Socket_Ok;
755cdf0e10cSrcweir }
756cdf0e10cSrcweir return res;
757cdf0e10cSrcweir }
758cdf0e10cSrcweir
759cdf0e10cSrcweir /*****************************************************************************/
760cdf0e10cSrcweir /* osl_getAddrOfSocketAddr */
761cdf0e10cSrcweir /*****************************************************************************/
osl_getAddrOfSocketAddr(oslSocketAddr pAddr,sal_Sequence ** ppByteSeq)762cdf0e10cSrcweir oslSocketResult SAL_CALL osl_getAddrOfSocketAddr( oslSocketAddr pAddr, sal_Sequence **ppByteSeq )
763cdf0e10cSrcweir {
764cdf0e10cSrcweir oslSocketResult res = osl_Socket_Error;
765cdf0e10cSrcweir
766cdf0e10cSrcweir OSL_ASSERT( pAddr );
767cdf0e10cSrcweir OSL_ASSERT( ppByteSeq );
768cdf0e10cSrcweir
769cdf0e10cSrcweir if( pAddr && ppByteSeq )
770cdf0e10cSrcweir {
771cdf0e10cSrcweir struct sockaddr_in * pSystemInetAddr = (struct sockaddr_in * ) &(pAddr->m_sockaddr);
772cdf0e10cSrcweir rtl_byte_sequence_constructFromArray( ppByteSeq , (sal_Int8 *) &(pSystemInetAddr->sin_addr),4);
773cdf0e10cSrcweir res = osl_Socket_Ok;
774cdf0e10cSrcweir }
775cdf0e10cSrcweir return res;
776cdf0e10cSrcweir }
777cdf0e10cSrcweir
778cdf0e10cSrcweir
779cdf0e10cSrcweir /*****************************************************************************/
780cdf0e10cSrcweir /* _osl_getFullQualifiedDomainName */
781cdf0e10cSrcweir /*****************************************************************************/
782cdf0e10cSrcweir
783cdf0e10cSrcweir /** try to figure out a full-qualified hostname, by adding the current domain
784cdf0e10cSrcweir as given by the domainname program to the given hostname.
785cdf0e10cSrcweir This function MUST NOT call gethostbyname since pHostName allready points
786cdf0e10cSrcweir to data returned by gethostname and would be garbled: use gethostname_r
787cdf0e10cSrcweir instead!
788cdf0e10cSrcweir */
789cdf0e10cSrcweir
790cdf0e10cSrcweir /* wrap around different interfaces to reentrant gethostbyname */
_osl_gethostbyname_r(const char * name,struct hostent * result,char * buffer,int buflen,int * h_errnop)791cdf0e10cSrcweir static struct hostent* _osl_gethostbyname_r (
792cdf0e10cSrcweir const char *name, struct hostent *result,
793cdf0e10cSrcweir char *buffer, int buflen, int *h_errnop)
794cdf0e10cSrcweir {
795cdf0e10cSrcweir
796cdf0e10cSrcweir #ifdef LINUX
797cdf0e10cSrcweir struct hostent *__result; /* will be the same as result */
798cdf0e10cSrcweir int __error;
799cdf0e10cSrcweir __error = gethostbyname_r (name, result, buffer, buflen,
800cdf0e10cSrcweir &__result, h_errnop);
801cdf0e10cSrcweir return __error ? NULL : __result ;
802cdf0e10cSrcweir #elif defined OS2
803cdf0e10cSrcweir // YD FIXME!!!
804cdf0e10cSrcweir return 0;
805cdf0e10cSrcweir #else
806cdf0e10cSrcweir return gethostbyname_r( name, result, buffer, buflen, h_errnop);
807cdf0e10cSrcweir #endif
808cdf0e10cSrcweir }
809cdf0e10cSrcweir
_osl_getDomainName(sal_Char * buffer,sal_Int32 bufsiz)810cdf0e10cSrcweir static sal_Bool _osl_getDomainName (sal_Char *buffer, sal_Int32 bufsiz)
811cdf0e10cSrcweir {
812cdf0e10cSrcweir sal_Bool result;
813cdf0e10cSrcweir int p[2];
814cdf0e10cSrcweir
815cdf0e10cSrcweir result = sal_False;
816cdf0e10cSrcweir
817cdf0e10cSrcweir #if 0 // YD 17/04/06 libc panic for fork() from thread!=1
818cdf0e10cSrcweir
819cdf0e10cSrcweir if (pipe (p) == 0)
820cdf0e10cSrcweir {
821cdf0e10cSrcweir pid_t pid;
822cdf0e10cSrcweir int nStatus;
823cdf0e10cSrcweir
824cdf0e10cSrcweir pid = fork();
825cdf0e10cSrcweir if (pid == 0)
826cdf0e10cSrcweir {
827cdf0e10cSrcweir char *argv[] =
828cdf0e10cSrcweir {
829cdf0e10cSrcweir "/bin/domainname",
830cdf0e10cSrcweir NULL
831cdf0e10cSrcweir };
832cdf0e10cSrcweir
833cdf0e10cSrcweir close (p[0]);
834cdf0e10cSrcweir dup2 (p[1], 1);
835cdf0e10cSrcweir close (p[1]);
836cdf0e10cSrcweir
837cdf0e10cSrcweir execv ("/bin/domainname", argv);
838cdf0e10cSrcweir // arriving here means exec failed
839cdf0e10cSrcweir _exit(-1);
840cdf0e10cSrcweir }
841cdf0e10cSrcweir else if (pid > 0)
842cdf0e10cSrcweir {
843cdf0e10cSrcweir sal_Int32 k = 0, n = bufsiz;
844cdf0e10cSrcweir
845cdf0e10cSrcweir close (p[1]);
846cdf0e10cSrcweir if ((k = read (p[0], buffer, n - 1)) > 0)
847cdf0e10cSrcweir {
848cdf0e10cSrcweir buffer[k] = 0;
849cdf0e10cSrcweir if (buffer[k - 1] == '\n')
850cdf0e10cSrcweir buffer[k - 1] = 0;
851cdf0e10cSrcweir result = sal_True;
852cdf0e10cSrcweir }
853cdf0e10cSrcweir close (p[0]);
854cdf0e10cSrcweir waitpid (pid, &nStatus, 0);
855cdf0e10cSrcweir }
856cdf0e10cSrcweir else
857cdf0e10cSrcweir {
858cdf0e10cSrcweir close (p[0]);
859cdf0e10cSrcweir close (p[1]);
860cdf0e10cSrcweir }
861cdf0e10cSrcweir }
862cdf0e10cSrcweir #endif // 0
863cdf0e10cSrcweir
864cdf0e10cSrcweir return (result);
865cdf0e10cSrcweir }
866cdf0e10cSrcweir
_osl_getFullQualifiedDomainName(const sal_Char * pHostName)867cdf0e10cSrcweir static sal_Char* _osl_getFullQualifiedDomainName (const sal_Char *pHostName)
868cdf0e10cSrcweir {
869cdf0e10cSrcweir # define DOMAINNAME_LENGTH 512
870cdf0e10cSrcweir sal_uInt32 nLengthOfHostName;
871cdf0e10cSrcweir static sal_uInt32 nLengthOfDomainName = 0;
872cdf0e10cSrcweir static sal_Char *pDomainName = NULL;
873cdf0e10cSrcweir
874cdf0e10cSrcweir sal_Char *pFullQualifiedName;
875cdf0e10cSrcweir #if 0 /* OBSOLETE */
876cdf0e10cSrcweir FILE *pPipeToDomainnameExe;
877cdf0e10cSrcweir #endif /* OBSOLETE */
878cdf0e10cSrcweir
879cdf0e10cSrcweir /* get a '\0' terminated domainname */
880cdf0e10cSrcweir
881cdf0e10cSrcweir /* read default domainname default from environment */
882cdf0e10cSrcweir if (nLengthOfDomainName == 0)
883cdf0e10cSrcweir {
884cdf0e10cSrcweir sal_Char *pEnvDomain;
885cdf0e10cSrcweir
886cdf0e10cSrcweir pEnvDomain = getenv ("STAR_OVERRIDE_DOMAINNAME");
887cdf0e10cSrcweir if (pEnvDomain)
888cdf0e10cSrcweir {
889cdf0e10cSrcweir pDomainName = strdup (pEnvDomain);
890cdf0e10cSrcweir nLengthOfDomainName = strlen (pDomainName);
891cdf0e10cSrcweir }
892cdf0e10cSrcweir }
893cdf0e10cSrcweir
894cdf0e10cSrcweir #if 1 /* NEW */
895cdf0e10cSrcweir if (nLengthOfDomainName == 0)
896cdf0e10cSrcweir {
897cdf0e10cSrcweir sal_Char pDomainNameBuffer[ DOMAINNAME_LENGTH ];
898cdf0e10cSrcweir
899cdf0e10cSrcweir pDomainNameBuffer[0] = '\0';
900cdf0e10cSrcweir
901cdf0e10cSrcweir if (_osl_getDomainName (pDomainNameBuffer, DOMAINNAME_LENGTH))
902cdf0e10cSrcweir {
903cdf0e10cSrcweir pDomainName = strdup (pDomainNameBuffer);
904cdf0e10cSrcweir nLengthOfDomainName = strlen (pDomainName);
905cdf0e10cSrcweir }
906cdf0e10cSrcweir }
907cdf0e10cSrcweir
908cdf0e10cSrcweir #endif /* NEW */
909cdf0e10cSrcweir #if 0 /* OBSOLETE */
910cdf0e10cSrcweir #ifdef SCO
911cdf0e10cSrcweir
912cdf0e10cSrcweir /* call 'domainname > /usr/tmp/some-tmp-file', since
913cdf0e10cSrcweir popen read pclose do block or core-dump,
914cdf0e10cSrcweir (even the pipe-stuff that comes with pthreads) */
915cdf0e10cSrcweir if (nLengthOfDomainName == 0)
916cdf0e10cSrcweir {
917cdf0e10cSrcweir sal_Char tmp_name[ L_tmpnam ];
918cdf0e10cSrcweir FILE *tmp_file;
919cdf0e10cSrcweir sal_Char domain_call [ L_tmpnam + 16 ] = "domainname > ";
920cdf0e10cSrcweir
921cdf0e10cSrcweir tmp_name[0] = '\0';
922cdf0e10cSrcweir
923cdf0e10cSrcweir tmpnam ( tmp_name );
924cdf0e10cSrcweir strcat ( domain_call, tmp_name );
925cdf0e10cSrcweir if ( (system ( domain_call ) == 0)
926cdf0e10cSrcweir && ((tmp_file = fopen( tmp_name, "r" )) != NULL ) )
927cdf0e10cSrcweir {
928cdf0e10cSrcweir sal_Char pDomainNameBuffer[ DOMAINNAME_LENGTH ];
929cdf0e10cSrcweir
930cdf0e10cSrcweir pDomainNameBuffer[0] = '\0';
931cdf0e10cSrcweir
932cdf0e10cSrcweir if ( fgets ( pDomainNameBuffer, DOMAINNAME_LENGTH, tmp_file ) )
933cdf0e10cSrcweir {
934cdf0e10cSrcweir pDomainName = strdup( pDomainNameBuffer );
935cdf0e10cSrcweir nLengthOfDomainName = strlen( pDomainName );
936cdf0e10cSrcweir if ( ( nLengthOfDomainName > 0 )
937cdf0e10cSrcweir && ( pDomainName[ nLengthOfDomainName - 1] == '\n' ) )
938cdf0e10cSrcweir pDomainName[ --nLengthOfDomainName ] = '\0';
939cdf0e10cSrcweir }
940cdf0e10cSrcweir fclose ( tmp_file );
941cdf0e10cSrcweir }
942cdf0e10cSrcweir unlink( tmp_name );
943cdf0e10cSrcweir }
944cdf0e10cSrcweir
945cdf0e10cSrcweir #else /* !SCO */
946cdf0e10cSrcweir
947cdf0e10cSrcweir /* read the domainname from pipe to the program domainname */
948cdf0e10cSrcweir if ( (nLengthOfDomainName == 0)
949cdf0e10cSrcweir && (pPipeToDomainnameExe = popen( "domainname", "r")) )
950cdf0e10cSrcweir {
951cdf0e10cSrcweir sal_Char c;
952cdf0e10cSrcweir sal_Char pDomainNameBuffer[ DOMAINNAME_LENGTH ];
953cdf0e10cSrcweir sal_Char *pDomainNamePointer;
954cdf0e10cSrcweir
955cdf0e10cSrcweir pDomainNameBuffer[0] = '\0';
956cdf0e10cSrcweir
957cdf0e10cSrcweir pDomainNamePointer = pDomainNameBuffer;
958cdf0e10cSrcweir while ( ((c = getc( pPipeToDomainnameExe )) != EOF)
959cdf0e10cSrcweir && (nLengthOfDomainName < (DOMAINNAME_LENGTH - 1)) )
960cdf0e10cSrcweir {
961cdf0e10cSrcweir if (! isspace(c))
962cdf0e10cSrcweir {
963cdf0e10cSrcweir nLengthOfDomainName++ ;
964cdf0e10cSrcweir *pDomainNamePointer++ = (sal_Char)c;
965cdf0e10cSrcweir }
966cdf0e10cSrcweir }
967cdf0e10cSrcweir *pDomainNamePointer = '\0';
968cdf0e10cSrcweir pDomainName = strdup( pDomainNameBuffer );
969cdf0e10cSrcweir
970cdf0e10cSrcweir pclose( pPipeToDomainnameExe );
971cdf0e10cSrcweir }
972cdf0e10cSrcweir
973cdf0e10cSrcweir #endif /* !SCO */
974cdf0e10cSrcweir #endif /* OBSOLETE */
975cdf0e10cSrcweir
976cdf0e10cSrcweir /* compose hostname and domainname */
977cdf0e10cSrcweir nLengthOfHostName = strlen( pHostName );
978cdf0e10cSrcweir pFullQualifiedName = (sal_Char*) malloc( (nLengthOfHostName + 1
979cdf0e10cSrcweir + nLengthOfDomainName + 1) * sizeof(sal_Char) );
980cdf0e10cSrcweir memcpy( pFullQualifiedName, pHostName,
981cdf0e10cSrcweir (nLengthOfHostName + 1) * sizeof(sal_Char) );
982cdf0e10cSrcweir
983cdf0e10cSrcweir if ( nLengthOfDomainName > 0 )
984cdf0e10cSrcweir {
985cdf0e10cSrcweir /* fqdn = hostname + '.' + domainname + '\0' */
986cdf0e10cSrcweir pFullQualifiedName[ nLengthOfHostName ] = '.';
987cdf0e10cSrcweir memcpy( pFullQualifiedName + nLengthOfHostName + 1, pDomainName,
988cdf0e10cSrcweir nLengthOfDomainName + 1 );
989cdf0e10cSrcweir }
990cdf0e10cSrcweir
991cdf0e10cSrcweir /* check whether full-qualified name and hostname point to the same host
992cdf0e10cSrcweir * should almost always be true */
993cdf0e10cSrcweir if ( nLengthOfDomainName > 0 )
994cdf0e10cSrcweir {
995cdf0e10cSrcweir struct hostent *pQualifiedHostByName;
996cdf0e10cSrcweir struct hostent *pHostByName;
997cdf0e10cSrcweir sal_Bool bHostsAreEqual;
998cdf0e10cSrcweir
999cdf0e10cSrcweir /* buffer for calls to reentrant version of gethostbyname */
1000cdf0e10cSrcweir struct hostent aHostByName, aQualifiedHostByName;
1001cdf0e10cSrcweir sal_Char pHostBuffer[ MAX_HOSTBUFFER_SIZE ];
1002cdf0e10cSrcweir sal_Char pQualifiedHostBuffer[ MAX_HOSTBUFFER_SIZE ];
1003cdf0e10cSrcweir int nErrorNo;
1004cdf0e10cSrcweir
1005cdf0e10cSrcweir pHostBuffer[0] = '\0';
1006cdf0e10cSrcweir pQualifiedHostBuffer[0] = '\0';
1007cdf0e10cSrcweir
1008cdf0e10cSrcweir /* get list of addresses */
1009cdf0e10cSrcweir pQualifiedHostByName = _osl_gethostbyname_r (
1010cdf0e10cSrcweir pFullQualifiedName,
1011cdf0e10cSrcweir &aQualifiedHostByName, pQualifiedHostBuffer,
1012cdf0e10cSrcweir sizeof(pQualifiedHostBuffer), &nErrorNo );
1013cdf0e10cSrcweir pHostByName = _osl_gethostbyname_r (
1014cdf0e10cSrcweir pHostName,
1015cdf0e10cSrcweir &aHostByName, pHostBuffer,
1016cdf0e10cSrcweir sizeof(pHostBuffer), &nErrorNo );
1017cdf0e10cSrcweir
1018cdf0e10cSrcweir /* compare addresses */
1019cdf0e10cSrcweir bHostsAreEqual = sal_False;
1020cdf0e10cSrcweir if ( pQualifiedHostByName && pHostByName )
1021cdf0e10cSrcweir {
1022cdf0e10cSrcweir sal_Char **p, **q;
1023cdf0e10cSrcweir struct in_addr in;
1024cdf0e10cSrcweir
1025cdf0e10cSrcweir /* lists are expected to be (very) short */
1026cdf0e10cSrcweir for ( p = pQualifiedHostByName->h_addr_list; *p != NULL; p++ )
1027cdf0e10cSrcweir {
1028cdf0e10cSrcweir for ( q = pHostByName->h_addr_list; *q != NULL; q++ )
1029cdf0e10cSrcweir {
1030cdf0e10cSrcweir /* in.s_addr may be in_addr_t or uint32_t or heaven knows */
1031cdf0e10cSrcweir if ( memcmp( *p, *q, sizeof(in.s_addr) ) == 0 )
1032cdf0e10cSrcweir {
1033cdf0e10cSrcweir bHostsAreEqual = sal_True;
1034cdf0e10cSrcweir break;
1035cdf0e10cSrcweir }
1036cdf0e10cSrcweir }
1037cdf0e10cSrcweir if ( bHostsAreEqual )
1038cdf0e10cSrcweir break;
1039cdf0e10cSrcweir }
1040cdf0e10cSrcweir }
1041cdf0e10cSrcweir
1042cdf0e10cSrcweir /* very strange case, but have to believe it: reduce the
1043cdf0e10cSrcweir * full qualified name to the unqualified host name */
1044cdf0e10cSrcweir if ( !bHostsAreEqual )
1045cdf0e10cSrcweir {
1046cdf0e10cSrcweir OSL_TRACE("_osl_getFullQualifiedDomainName: "
1047cdf0e10cSrcweir "suspect FQDN: %s\n", pFullQualifiedName);
1048cdf0e10cSrcweir
1049cdf0e10cSrcweir pFullQualifiedName[ nLengthOfHostName ] = '\0';
1050cdf0e10cSrcweir pFullQualifiedName = (sal_Char*)realloc ( pFullQualifiedName,
1051cdf0e10cSrcweir (nLengthOfHostName + 1) * sizeof( sal_Char ));
1052cdf0e10cSrcweir }
1053cdf0e10cSrcweir }
1054cdf0e10cSrcweir
1055cdf0e10cSrcweir /* always return a hostname looked up as carefully as possible
1056cdf0e10cSrcweir * this string must be freed by the caller */
1057cdf0e10cSrcweir return pFullQualifiedName;
1058cdf0e10cSrcweir }
1059cdf0e10cSrcweir
1060cdf0e10cSrcweir /*****************************************************************************/
1061cdf0e10cSrcweir /* _osl_isFullQualifiedDomainName */
1062cdf0e10cSrcweir /*****************************************************************************/
_osl_isFullQualifiedDomainName(const sal_Char * pHostName)1063cdf0e10cSrcweir static sal_Bool _osl_isFullQualifiedDomainName (const sal_Char *pHostName)
1064cdf0e10cSrcweir {
1065cdf0e10cSrcweir /* a FQDN (aka 'hostname.domain.top_level_domain' )
1066cdf0e10cSrcweir * is a name which contains a dot '.' in it ( would
1067cdf0e10cSrcweir * match as well for 'hostname.' but is good enough
1068cdf0e10cSrcweir * for now )*/
1069cdf0e10cSrcweir return (sal_Bool)( strchr( pHostName, (int)'.' ) != NULL );
1070cdf0e10cSrcweir }
1071cdf0e10cSrcweir
1072cdf0e10cSrcweir /*****************************************************************************/
1073cdf0e10cSrcweir /* oslHostAddr */
1074cdf0e10cSrcweir /*****************************************************************************/
1075cdf0e10cSrcweir struct oslHostAddrImpl
1076cdf0e10cSrcweir {
1077cdf0e10cSrcweir sal_Char *pHostName;
1078cdf0e10cSrcweir oslSocketAddr pSockAddr;
1079cdf0e10cSrcweir };
1080cdf0e10cSrcweir
_osl_hostentToHostAddr(const struct hostent * he)1081cdf0e10cSrcweir static oslHostAddr _osl_hostentToHostAddr (const struct hostent *he)
1082cdf0e10cSrcweir {
1083cdf0e10cSrcweir oslHostAddr pAddr= NULL;
1084cdf0e10cSrcweir oslSocketAddr pSockAddr = 0;
1085cdf0e10cSrcweir
1086cdf0e10cSrcweir
1087cdf0e10cSrcweir if ((he == NULL) || (he->h_name == NULL) || (he->h_addr_list[0] == NULL))
1088cdf0e10cSrcweir return ((oslHostAddr)NULL);
1089cdf0e10cSrcweir
1090cdf0e10cSrcweir //YD 18/06/2006 win32 does this with unicode, see socket.cxx
1091cdf0e10cSrcweir sal_Char *cn;
1092cdf0e10cSrcweir cn= (sal_Char *)malloc(strlen (he->h_name) + 1);
1093cdf0e10cSrcweir OSL_ASSERT(cn);
1094cdf0e10cSrcweir if (cn == NULL)
1095cdf0e10cSrcweir return ((oslHostAddr)NULL);
1096cdf0e10cSrcweir
1097cdf0e10cSrcweir strcpy(cn, he->h_name);
1098cdf0e10cSrcweir
1099cdf0e10cSrcweir #if 0 // YD 17/04/06 win32 doesn't it.
1100cdf0e10cSrcweir if (_osl_isFullQualifiedDomainName(he->h_name))
1101cdf0e10cSrcweir {
1102cdf0e10cSrcweir cn= (sal_Char *)malloc(strlen (he->h_name) + 1);
1103cdf0e10cSrcweir OSL_ASSERT(cn);
1104cdf0e10cSrcweir if (cn == NULL)
1105cdf0e10cSrcweir return ((oslHostAddr)NULL);
1106cdf0e10cSrcweir
1107cdf0e10cSrcweir strcpy(cn, he->h_name);
1108cdf0e10cSrcweir }
1109cdf0e10cSrcweir else
1110cdf0e10cSrcweir {
1111cdf0e10cSrcweir cn =_osl_getFullQualifiedDomainName (he->h_name);
1112cdf0e10cSrcweir OSL_ASSERT(cn);
1113cdf0e10cSrcweir if (cn == NULL)
1114cdf0e10cSrcweir return ((oslHostAddr)NULL);
1115cdf0e10cSrcweir }
1116cdf0e10cSrcweir #endif
1117cdf0e10cSrcweir
1118cdf0e10cSrcweir pSockAddr = __osl_createSocketAddr();
1119cdf0e10cSrcweir OSL_ASSERT(pSockAddr);
1120cdf0e10cSrcweir if (pSockAddr == NULL)
1121cdf0e10cSrcweir {
1122cdf0e10cSrcweir free(cn);
1123cdf0e10cSrcweir return ((oslHostAddr)NULL);
1124cdf0e10cSrcweir }
1125cdf0e10cSrcweir
1126cdf0e10cSrcweir pSockAddr->m_sockaddr.sa_family= he->h_addrtype;
1127cdf0e10cSrcweir if (pSockAddr->m_sockaddr.sa_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
1128cdf0e10cSrcweir {
1129cdf0e10cSrcweir struct sockaddr_in *sin= (struct sockaddr_in *)&(pSockAddr->m_sockaddr);
1130cdf0e10cSrcweir memcpy (
1131cdf0e10cSrcweir &(sin->sin_addr.s_addr),
1132cdf0e10cSrcweir he->h_addr_list[0],
1133cdf0e10cSrcweir he->h_length);
1134cdf0e10cSrcweir }
1135cdf0e10cSrcweir else
1136cdf0e10cSrcweir {
1137cdf0e10cSrcweir /* unknown address family */
1138cdf0e10cSrcweir /* future extensions for new families might be implemented here */
1139cdf0e10cSrcweir
1140cdf0e10cSrcweir OSL_TRACE("_osl_hostentToHostAddr: unknown address family.\n");
1141cdf0e10cSrcweir OSL_ASSERT(sal_False);
1142cdf0e10cSrcweir
1143cdf0e10cSrcweir __osl_destroySocketAddr( pSockAddr );
1144cdf0e10cSrcweir free (cn);
1145cdf0e10cSrcweir return ((oslHostAddr)NULL);
1146cdf0e10cSrcweir }
1147cdf0e10cSrcweir
1148cdf0e10cSrcweir pAddr= (oslHostAddr) malloc(sizeof(struct oslHostAddrImpl));
1149cdf0e10cSrcweir OSL_ASSERT(pAddr);
1150cdf0e10cSrcweir if (pAddr == NULL)
1151cdf0e10cSrcweir {
1152cdf0e10cSrcweir __osl_destroySocketAddr( pSockAddr );
1153cdf0e10cSrcweir free (cn);
1154cdf0e10cSrcweir return ((oslHostAddr)NULL);
1155cdf0e10cSrcweir }
1156cdf0e10cSrcweir
1157cdf0e10cSrcweir pAddr->pHostName= cn;
1158cdf0e10cSrcweir pAddr->pSockAddr= pSockAddr;
1159cdf0e10cSrcweir
1160cdf0e10cSrcweir return pAddr;
1161cdf0e10cSrcweir }
1162cdf0e10cSrcweir
1163cdf0e10cSrcweir /*****************************************************************************/
1164cdf0e10cSrcweir /* osl_createHostAddr */
1165cdf0e10cSrcweir /*****************************************************************************/
osl_createHostAddr(rtl_uString * ustrHostname,const oslSocketAddr Addr)1166cdf0e10cSrcweir oslHostAddr SAL_CALL osl_createHostAddr (
1167cdf0e10cSrcweir rtl_uString *ustrHostname,
1168cdf0e10cSrcweir const oslSocketAddr Addr)
1169cdf0e10cSrcweir {
1170cdf0e10cSrcweir oslHostAddr HostAddr;
1171cdf0e10cSrcweir rtl_String* strHostname=0;
1172cdf0e10cSrcweir sal_Char* pszHostName=0;
1173cdf0e10cSrcweir
1174cdf0e10cSrcweir if ( ustrHostname != 0 )
1175cdf0e10cSrcweir {
1176cdf0e10cSrcweir rtl_uString2String( &strHostname,
1177cdf0e10cSrcweir rtl_uString_getStr(ustrHostname),
1178cdf0e10cSrcweir rtl_uString_getLength(ustrHostname),
1179cdf0e10cSrcweir RTL_TEXTENCODING_UTF8,
1180cdf0e10cSrcweir OUSTRING_TO_OSTRING_CVTFLAGS );
1181cdf0e10cSrcweir pszHostName = rtl_string_getStr(strHostname);
1182cdf0e10cSrcweir }
1183cdf0e10cSrcweir
1184cdf0e10cSrcweir HostAddr = osl_psz_createHostAddr(pszHostName,Addr);
1185cdf0e10cSrcweir
1186cdf0e10cSrcweir if ( strHostname != 0 )
1187cdf0e10cSrcweir {
1188cdf0e10cSrcweir rtl_string_release(strHostname);
1189cdf0e10cSrcweir }
1190cdf0e10cSrcweir
1191cdf0e10cSrcweir
1192cdf0e10cSrcweir return HostAddr;
1193cdf0e10cSrcweir }
1194cdf0e10cSrcweir
osl_psz_createHostAddr(const sal_Char * pszHostname,const oslSocketAddr pAddr)1195cdf0e10cSrcweir oslHostAddr SAL_CALL osl_psz_createHostAddr (
1196cdf0e10cSrcweir const sal_Char *pszHostname,
1197cdf0e10cSrcweir const oslSocketAddr pAddr)
1198cdf0e10cSrcweir {
1199cdf0e10cSrcweir oslHostAddr pHostAddr;
1200cdf0e10cSrcweir sal_Char *cn;
1201cdf0e10cSrcweir
1202cdf0e10cSrcweir OSL_ASSERT(pszHostname && pAddr);
1203cdf0e10cSrcweir if ((pszHostname == NULL) || (pAddr == NULL))
1204cdf0e10cSrcweir return ((oslHostAddr)NULL);
1205cdf0e10cSrcweir
1206cdf0e10cSrcweir cn = (sal_Char *)malloc(strlen (pszHostname) + 1);
1207cdf0e10cSrcweir OSL_ASSERT(cn);
1208cdf0e10cSrcweir if (cn == NULL)
1209cdf0e10cSrcweir return ((oslHostAddr)NULL);
1210cdf0e10cSrcweir
1211cdf0e10cSrcweir strcpy (cn, pszHostname);
1212cdf0e10cSrcweir
1213cdf0e10cSrcweir pHostAddr= (oslHostAddr) malloc(sizeof(struct oslHostAddrImpl));
1214cdf0e10cSrcweir OSL_ASSERT(pHostAddr);
1215cdf0e10cSrcweir if (pAddr == NULL)
1216cdf0e10cSrcweir {
1217cdf0e10cSrcweir free (cn);
1218cdf0e10cSrcweir return ((oslHostAddr)NULL);
1219cdf0e10cSrcweir }
1220cdf0e10cSrcweir
1221cdf0e10cSrcweir pHostAddr->pHostName= cn;
1222cdf0e10cSrcweir pHostAddr->pSockAddr= osl_copySocketAddr( pAddr );
1223cdf0e10cSrcweir
1224cdf0e10cSrcweir return pHostAddr;
1225cdf0e10cSrcweir }
1226cdf0e10cSrcweir
1227cdf0e10cSrcweir /*****************************************************************************/
1228cdf0e10cSrcweir /* osl_createHostAddrByName */
1229cdf0e10cSrcweir /*****************************************************************************/
osl_createHostAddrByName(rtl_uString * ustrHostname)1230cdf0e10cSrcweir oslHostAddr SAL_CALL osl_createHostAddrByName(rtl_uString *ustrHostname)
1231cdf0e10cSrcweir {
1232cdf0e10cSrcweir oslHostAddr HostAddr;
1233cdf0e10cSrcweir rtl_String* strHostname=0;
1234cdf0e10cSrcweir sal_Char* pszHostName=0;
1235cdf0e10cSrcweir
1236cdf0e10cSrcweir if ( ustrHostname != 0 )
1237cdf0e10cSrcweir {
1238cdf0e10cSrcweir rtl_uString2String( &strHostname,
1239cdf0e10cSrcweir rtl_uString_getStr(ustrHostname),
1240cdf0e10cSrcweir rtl_uString_getLength(ustrHostname),
1241cdf0e10cSrcweir RTL_TEXTENCODING_UTF8,
1242cdf0e10cSrcweir OUSTRING_TO_OSTRING_CVTFLAGS );
1243cdf0e10cSrcweir pszHostName=rtl_string_getStr(strHostname);
1244cdf0e10cSrcweir }
1245cdf0e10cSrcweir
1246cdf0e10cSrcweir HostAddr = osl_psz_createHostAddrByName(pszHostName);
1247cdf0e10cSrcweir
1248cdf0e10cSrcweir if ( strHostname != 0 )
1249cdf0e10cSrcweir {
1250cdf0e10cSrcweir rtl_string_release(strHostname);
1251cdf0e10cSrcweir }
1252cdf0e10cSrcweir
1253cdf0e10cSrcweir return HostAddr;
1254cdf0e10cSrcweir }
1255cdf0e10cSrcweir
osl_psz_createHostAddrByName(const sal_Char * pszHostname)1256cdf0e10cSrcweir oslHostAddr SAL_CALL osl_psz_createHostAddrByName (const sal_Char *pszHostname)
1257cdf0e10cSrcweir {
1258cdf0e10cSrcweir struct hostent *he;
1259cdf0e10cSrcweir oslHostAddr addr;
1260cdf0e10cSrcweir
1261cdf0e10cSrcweir static oslMutex mutex = NULL;
1262cdf0e10cSrcweir
1263cdf0e10cSrcweir if (mutex == NULL)
1264cdf0e10cSrcweir mutex = osl_createMutex();
1265cdf0e10cSrcweir
1266cdf0e10cSrcweir osl_acquireMutex(mutex);
1267cdf0e10cSrcweir
1268cdf0e10cSrcweir he = gethostbyname((sal_Char *)pszHostname);
1269cdf0e10cSrcweir addr = _osl_hostentToHostAddr (he);
1270cdf0e10cSrcweir
1271cdf0e10cSrcweir osl_releaseMutex(mutex);
1272cdf0e10cSrcweir
1273cdf0e10cSrcweir return addr;
1274cdf0e10cSrcweir }
1275cdf0e10cSrcweir
1276cdf0e10cSrcweir /*****************************************************************************/
1277cdf0e10cSrcweir /* osl_createHostAddrByAddr */
1278cdf0e10cSrcweir /*****************************************************************************/
osl_createHostAddrByAddr(const oslSocketAddr pAddr)1279cdf0e10cSrcweir oslHostAddr SAL_CALL osl_createHostAddrByAddr (const oslSocketAddr pAddr)
1280cdf0e10cSrcweir {
1281cdf0e10cSrcweir OSL_ASSERT(pAddr);
1282cdf0e10cSrcweir
1283cdf0e10cSrcweir if (pAddr == NULL)
1284cdf0e10cSrcweir return ((oslHostAddr)NULL);
1285cdf0e10cSrcweir
1286cdf0e10cSrcweir if (pAddr->m_sockaddr.sa_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
1287cdf0e10cSrcweir {
1288cdf0e10cSrcweir const struct sockaddr_in *sin= (const struct sockaddr_in *)&(pAddr->m_sockaddr);
1289cdf0e10cSrcweir struct hostent *he;
1290cdf0e10cSrcweir
1291cdf0e10cSrcweir if (sin->sin_addr.s_addr == htonl(INADDR_ANY))
1292cdf0e10cSrcweir return ((oslHostAddr)NULL);
1293cdf0e10cSrcweir
1294cdf0e10cSrcweir he= gethostbyaddr((sal_Char *)&(sin->sin_addr),
1295cdf0e10cSrcweir sizeof (sin->sin_addr),
1296cdf0e10cSrcweir sin->sin_family);
1297cdf0e10cSrcweir return _osl_hostentToHostAddr (he);
1298cdf0e10cSrcweir }
1299cdf0e10cSrcweir
1300cdf0e10cSrcweir return ((oslHostAddr)NULL);
1301cdf0e10cSrcweir }
1302cdf0e10cSrcweir
1303cdf0e10cSrcweir /*****************************************************************************/
1304cdf0e10cSrcweir /* osl_copyHostAddr */
1305cdf0e10cSrcweir /*****************************************************************************/
osl_copyHostAddr(const oslHostAddr pAddr)1306cdf0e10cSrcweir oslHostAddr SAL_CALL osl_copyHostAddr (const oslHostAddr pAddr)
1307cdf0e10cSrcweir {
1308cdf0e10cSrcweir OSL_ASSERT(pAddr);
1309cdf0e10cSrcweir
1310cdf0e10cSrcweir if (pAddr)
1311cdf0e10cSrcweir return osl_psz_createHostAddr (pAddr->pHostName, pAddr->pSockAddr);
1312cdf0e10cSrcweir else
1313cdf0e10cSrcweir return ((oslHostAddr)NULL);
1314cdf0e10cSrcweir }
1315cdf0e10cSrcweir
1316cdf0e10cSrcweir /*****************************************************************************/
1317cdf0e10cSrcweir /* osl_getHostnameOfHostAddr */
1318cdf0e10cSrcweir /*****************************************************************************/
osl_getHostnameOfHostAddr(const oslHostAddr Addr,rtl_uString ** ustrHostname)1319cdf0e10cSrcweir void SAL_CALL osl_getHostnameOfHostAddr (
1320cdf0e10cSrcweir const oslHostAddr Addr,
1321cdf0e10cSrcweir rtl_uString **ustrHostname)
1322cdf0e10cSrcweir {
1323cdf0e10cSrcweir const sal_Char* pHostname=0;
1324cdf0e10cSrcweir
1325cdf0e10cSrcweir pHostname = osl_psz_getHostnameOfHostAddr(Addr);
1326cdf0e10cSrcweir
1327cdf0e10cSrcweir rtl_uString_newFromAscii (ustrHostname, pHostname);
1328cdf0e10cSrcweir
1329cdf0e10cSrcweir return;
1330cdf0e10cSrcweir }
1331cdf0e10cSrcweir
osl_psz_getHostnameOfHostAddr(const oslHostAddr pAddr)1332cdf0e10cSrcweir const sal_Char* SAL_CALL osl_psz_getHostnameOfHostAddr (const oslHostAddr pAddr)
1333cdf0e10cSrcweir {
1334cdf0e10cSrcweir OSL_ASSERT(pAddr);
1335cdf0e10cSrcweir
1336cdf0e10cSrcweir if (pAddr)
1337cdf0e10cSrcweir return pAddr->pHostName;
1338cdf0e10cSrcweir else
1339cdf0e10cSrcweir return NULL;
1340cdf0e10cSrcweir }
1341cdf0e10cSrcweir
1342cdf0e10cSrcweir /*****************************************************************************/
1343cdf0e10cSrcweir /* osl_getSocketAddrOfHostAddr */
1344cdf0e10cSrcweir /*****************************************************************************/
osl_getSocketAddrOfHostAddr(const oslHostAddr pAddr)1345cdf0e10cSrcweir oslSocketAddr SAL_CALL osl_getSocketAddrOfHostAddr (const oslHostAddr pAddr)
1346cdf0e10cSrcweir {
1347cdf0e10cSrcweir OSL_ASSERT(pAddr);
1348cdf0e10cSrcweir
1349cdf0e10cSrcweir if (pAddr)
1350cdf0e10cSrcweir return ((oslSocketAddr)(pAddr->pSockAddr));
1351cdf0e10cSrcweir else
1352cdf0e10cSrcweir return NULL;
1353cdf0e10cSrcweir }
1354cdf0e10cSrcweir
1355cdf0e10cSrcweir /*****************************************************************************/
1356cdf0e10cSrcweir /* osl_destroyHostAddr */
1357cdf0e10cSrcweir /*****************************************************************************/
osl_destroyHostAddr(oslHostAddr pAddr)1358cdf0e10cSrcweir void SAL_CALL osl_destroyHostAddr (oslHostAddr pAddr)
1359cdf0e10cSrcweir {
1360cdf0e10cSrcweir if (pAddr)
1361cdf0e10cSrcweir {
1362cdf0e10cSrcweir if (pAddr->pHostName)
1363cdf0e10cSrcweir free (pAddr->pHostName);
1364cdf0e10cSrcweir if (pAddr->pSockAddr)
1365cdf0e10cSrcweir osl_destroySocketAddr (pAddr->pSockAddr);
1366cdf0e10cSrcweir free (pAddr);
1367cdf0e10cSrcweir }
1368cdf0e10cSrcweir }
1369cdf0e10cSrcweir
1370cdf0e10cSrcweir /*****************************************************************************/
1371cdf0e10cSrcweir /* osl_getLocalHostname */
1372cdf0e10cSrcweir /*****************************************************************************/
osl_getLocalHostname(rtl_uString ** ustrLocalHostname)1373cdf0e10cSrcweir oslSocketResult SAL_CALL osl_getLocalHostname(rtl_uString **ustrLocalHostname)
1374cdf0e10cSrcweir {
1375cdf0e10cSrcweir oslSocketResult Result;
1376cdf0e10cSrcweir sal_Char pszHostname[1024];
1377cdf0e10cSrcweir
1378cdf0e10cSrcweir pszHostname[0] = '\0';
1379cdf0e10cSrcweir
1380cdf0e10cSrcweir Result = osl_psz_getLocalHostname(pszHostname,sizeof(pszHostname));
1381cdf0e10cSrcweir
1382cdf0e10cSrcweir rtl_uString_newFromAscii(ustrLocalHostname,pszHostname);
1383cdf0e10cSrcweir
1384cdf0e10cSrcweir return Result;
1385cdf0e10cSrcweir }
1386cdf0e10cSrcweir
osl_psz_getLocalHostname(sal_Char * pBuffer,sal_uInt32 nBufLen)1387cdf0e10cSrcweir oslSocketResult SAL_CALL osl_psz_getLocalHostname (
1388cdf0e10cSrcweir sal_Char *pBuffer, sal_uInt32 nBufLen)
1389cdf0e10cSrcweir {
1390cdf0e10cSrcweir static sal_Char LocalHostname[256] = "";
1391cdf0e10cSrcweir
1392cdf0e10cSrcweir if (strlen(LocalHostname) == 0)
1393cdf0e10cSrcweir {
1394cdf0e10cSrcweir const sal_Char *pStr;
1395cdf0e10cSrcweir
1396cdf0e10cSrcweir #ifdef SYSV
1397cdf0e10cSrcweir struct utsname uts;
1398cdf0e10cSrcweir
1399cdf0e10cSrcweir if (uname(&uts) < 0)
1400cdf0e10cSrcweir return osl_Socket_Error;
1401cdf0e10cSrcweir
1402cdf0e10cSrcweir if ((strlen(uts.nodename) + 1) > nBufLen)
1403cdf0e10cSrcweir return osl_Socket_Error;
1404cdf0e10cSrcweir
1405cdf0e10cSrcweir strncpy(LocalHostname, uts.nodename, sizeof( LocalHostname ));
1406cdf0e10cSrcweir #else /* BSD compatible */
1407cdf0e10cSrcweir
1408cdf0e10cSrcweir if (gethostname(LocalHostname, sizeof(LocalHostname)-1) != 0)
1409cdf0e10cSrcweir return osl_Socket_Error;
1410cdf0e10cSrcweir LocalHostname[sizeof(LocalHostname)-1] = 0;
1411cdf0e10cSrcweir #endif /* SYSV */
1412cdf0e10cSrcweir
1413cdf0e10cSrcweir /* check if we have an FQDN */
1414cdf0e10cSrcweir if (strchr(LocalHostname, '.') == NULL)
1415cdf0e10cSrcweir {
1416cdf0e10cSrcweir oslHostAddr Addr;
1417cdf0e10cSrcweir
1418cdf0e10cSrcweir /* no, determine it via dns */
1419cdf0e10cSrcweir Addr = osl_psz_createHostAddrByName(LocalHostname);
1420cdf0e10cSrcweir
1421cdf0e10cSrcweir if (Addr && (pStr = osl_psz_getHostnameOfHostAddr(Addr)) != NULL)
1422cdf0e10cSrcweir {
1423cdf0e10cSrcweir #if 0 /* OBSOLETE */
1424cdf0e10cSrcweir sal_Char* pChr;
1425cdf0e10cSrcweir #endif /* OBSOLETE */
1426cdf0e10cSrcweir strcpy(LocalHostname, pStr);
1427cdf0e10cSrcweir
1428cdf0e10cSrcweir #if 0 /* OBSOLETE */
1429cdf0e10cSrcweir /* already done by _osl_getFullQualifiedDomainName() with
1430cdf0e10cSrcweir much better heuristics, so this may be contraproductive */
1431cdf0e10cSrcweir
1432cdf0e10cSrcweir /* no FQDN, last try append domain name */
1433cdf0e10cSrcweir if ((pChr = strchr(LocalHostname, '.')) == NULL)
1434cdf0e10cSrcweir {
1435cdf0e10cSrcweir FILE *fp;
1436cdf0e10cSrcweir
1437cdf0e10cSrcweir pChr = &LocalHostname[strlen(LocalHostname)];
1438cdf0e10cSrcweir
1439cdf0e10cSrcweir if ( (fp = popen("domainname", "r")) != 0 )
1440cdf0e10cSrcweir {
1441cdf0e10cSrcweir int c;
1442cdf0e10cSrcweir
1443cdf0e10cSrcweir *pChr++ = '.';
1444cdf0e10cSrcweir
1445cdf0e10cSrcweir while ((c = getc(fp)) != EOF)
1446cdf0e10cSrcweir {
1447cdf0e10cSrcweir if (! isspace(c))
1448cdf0e10cSrcweir *pChr++ = (sal_Char)c;
1449cdf0e10cSrcweir }
1450cdf0e10cSrcweir
1451cdf0e10cSrcweir *pChr = '\0';
1452cdf0e10cSrcweir
1453cdf0e10cSrcweir fclose(fp);
1454cdf0e10cSrcweir }
1455cdf0e10cSrcweir else
1456cdf0e10cSrcweir LocalHostname[0] = '\0';
1457cdf0e10cSrcweir }
1458cdf0e10cSrcweir #endif /* OBSOLETE */
1459cdf0e10cSrcweir
1460cdf0e10cSrcweir }
1461cdf0e10cSrcweir if (Addr)
1462cdf0e10cSrcweir osl_destroyHostAddr(Addr);
1463cdf0e10cSrcweir }
1464cdf0e10cSrcweir }
1465cdf0e10cSrcweir
1466cdf0e10cSrcweir if (strlen(LocalHostname) > 0)
1467cdf0e10cSrcweir {
1468cdf0e10cSrcweir strncpy(pBuffer, LocalHostname, nBufLen);
1469cdf0e10cSrcweir pBuffer[nBufLen - 1] = '\0';
1470cdf0e10cSrcweir
1471cdf0e10cSrcweir return osl_Socket_Ok;
1472cdf0e10cSrcweir }
1473cdf0e10cSrcweir
1474cdf0e10cSrcweir return osl_Socket_Error;
1475cdf0e10cSrcweir }
1476cdf0e10cSrcweir
1477cdf0e10cSrcweir /*****************************************************************************/
1478cdf0e10cSrcweir /* osl_resolveHostname */
1479cdf0e10cSrcweir /*****************************************************************************/
osl_resolveHostname(rtl_uString * ustrHostname)1480cdf0e10cSrcweir oslSocketAddr SAL_CALL osl_resolveHostname(rtl_uString *ustrHostname)
1481cdf0e10cSrcweir {
1482cdf0e10cSrcweir oslSocketAddr Addr;
1483cdf0e10cSrcweir rtl_String* strHostname=0;
1484cdf0e10cSrcweir sal_Char* pszHostName=0;
1485cdf0e10cSrcweir
1486cdf0e10cSrcweir if ( ustrHostname != 0 )
1487cdf0e10cSrcweir {
1488cdf0e10cSrcweir rtl_uString2String( &strHostname,
1489cdf0e10cSrcweir rtl_uString_getStr(ustrHostname),
1490cdf0e10cSrcweir rtl_uString_getLength(ustrHostname),
1491cdf0e10cSrcweir RTL_TEXTENCODING_UTF8,
1492cdf0e10cSrcweir OUSTRING_TO_OSTRING_CVTFLAGS );
1493cdf0e10cSrcweir pszHostName = rtl_string_getStr(strHostname);
1494cdf0e10cSrcweir }
1495cdf0e10cSrcweir
1496cdf0e10cSrcweir
1497cdf0e10cSrcweir Addr = osl_psz_resolveHostname(pszHostName);
1498cdf0e10cSrcweir
1499cdf0e10cSrcweir if ( strHostname != 0 )
1500cdf0e10cSrcweir {
1501cdf0e10cSrcweir rtl_string_release(strHostname);
1502cdf0e10cSrcweir }
1503cdf0e10cSrcweir
1504cdf0e10cSrcweir
1505cdf0e10cSrcweir return Addr;
1506cdf0e10cSrcweir }
1507cdf0e10cSrcweir
1508cdf0e10cSrcweir
osl_psz_resolveHostname(const sal_Char * pszHostname)1509cdf0e10cSrcweir oslSocketAddr SAL_CALL osl_psz_resolveHostname(const sal_Char* pszHostname)
1510cdf0e10cSrcweir {
1511cdf0e10cSrcweir struct oslHostAddrImpl *pAddr = (oslHostAddr)osl_psz_createHostAddrByName(pszHostname);
1512cdf0e10cSrcweir
1513cdf0e10cSrcweir if (pAddr)
1514cdf0e10cSrcweir {
1515cdf0e10cSrcweir oslSocketAddr SockAddr = osl_copySocketAddr(pAddr->pSockAddr);
1516cdf0e10cSrcweir
1517cdf0e10cSrcweir osl_destroyHostAddr(pAddr);
1518cdf0e10cSrcweir
1519cdf0e10cSrcweir return (SockAddr);
1520cdf0e10cSrcweir }
1521cdf0e10cSrcweir
1522cdf0e10cSrcweir return ((oslSocketAddr)NULL);
1523cdf0e10cSrcweir }
1524cdf0e10cSrcweir
1525cdf0e10cSrcweir /*****************************************************************************/
1526cdf0e10cSrcweir /* osl_getServicePort */
1527cdf0e10cSrcweir /*****************************************************************************/
osl_getServicePort(rtl_uString * ustrServicename,rtl_uString * ustrProtocol)1528cdf0e10cSrcweir sal_Int32 SAL_CALL osl_getServicePort(rtl_uString *ustrServicename, rtl_uString *ustrProtocol)
1529cdf0e10cSrcweir {
1530cdf0e10cSrcweir sal_Int32 nPort;
1531cdf0e10cSrcweir rtl_String* strServicename=0;
1532cdf0e10cSrcweir rtl_String* strProtocol=0;
1533cdf0e10cSrcweir sal_Char* pszServiceName=0;
1534cdf0e10cSrcweir sal_Char* pszProtocol=0;
1535cdf0e10cSrcweir
1536cdf0e10cSrcweir if ( ustrServicename != 0 )
1537cdf0e10cSrcweir {
1538cdf0e10cSrcweir rtl_uString2String( &strServicename,
1539cdf0e10cSrcweir rtl_uString_getStr(ustrServicename),
1540cdf0e10cSrcweir rtl_uString_getLength(ustrServicename),
1541cdf0e10cSrcweir RTL_TEXTENCODING_UTF8,
1542cdf0e10cSrcweir OUSTRING_TO_OSTRING_CVTFLAGS );
1543cdf0e10cSrcweir pszServiceName = rtl_string_getStr(strServicename);
1544cdf0e10cSrcweir }
1545cdf0e10cSrcweir
1546cdf0e10cSrcweir if ( ustrProtocol != 0 )
1547cdf0e10cSrcweir {
1548cdf0e10cSrcweir rtl_uString2String( &strProtocol,
1549cdf0e10cSrcweir rtl_uString_getStr(ustrProtocol),
1550cdf0e10cSrcweir rtl_uString_getLength(ustrProtocol),
1551cdf0e10cSrcweir RTL_TEXTENCODING_UTF8,
1552cdf0e10cSrcweir OUSTRING_TO_OSTRING_CVTFLAGS );
1553cdf0e10cSrcweir pszProtocol = rtl_string_getStr(strProtocol);
1554cdf0e10cSrcweir }
1555cdf0e10cSrcweir
1556cdf0e10cSrcweir nPort = osl_psz_getServicePort(pszServiceName,pszProtocol);
1557cdf0e10cSrcweir
1558cdf0e10cSrcweir if ( strServicename != 0 )
1559cdf0e10cSrcweir {
1560cdf0e10cSrcweir rtl_string_release(strServicename);
1561cdf0e10cSrcweir }
1562cdf0e10cSrcweir
1563cdf0e10cSrcweir if ( strProtocol != 0 )
1564cdf0e10cSrcweir {
1565cdf0e10cSrcweir rtl_string_release(strProtocol);
1566cdf0e10cSrcweir }
1567cdf0e10cSrcweir
1568cdf0e10cSrcweir
1569cdf0e10cSrcweir return nPort;
1570cdf0e10cSrcweir }
1571cdf0e10cSrcweir
1572cdf0e10cSrcweir
osl_psz_getServicePort(const sal_Char * pszServicename,const sal_Char * pszProtocol)1573cdf0e10cSrcweir sal_Int32 SAL_CALL osl_psz_getServicePort(const sal_Char* pszServicename,
1574cdf0e10cSrcweir const sal_Char* pszProtocol)
1575cdf0e10cSrcweir {
1576cdf0e10cSrcweir struct servent* ps;
1577cdf0e10cSrcweir
1578cdf0e10cSrcweir ps= getservbyname(pszServicename, pszProtocol);
1579cdf0e10cSrcweir
1580cdf0e10cSrcweir if (ps != 0)
1581cdf0e10cSrcweir return ntohs(ps->s_port);
1582cdf0e10cSrcweir
1583cdf0e10cSrcweir return OSL_INVALID_PORT;
1584cdf0e10cSrcweir }
1585cdf0e10cSrcweir
1586cdf0e10cSrcweir /*****************************************************************************/
1587cdf0e10cSrcweir /* osl_destroySocketAddr */
1588cdf0e10cSrcweir /*****************************************************************************/
osl_destroySocketAddr(oslSocketAddr pAddr)1589cdf0e10cSrcweir void SAL_CALL osl_destroySocketAddr(oslSocketAddr pAddr)
1590cdf0e10cSrcweir {
1591cdf0e10cSrcweir __osl_destroySocketAddr( pAddr );
1592cdf0e10cSrcweir }
1593cdf0e10cSrcweir
1594cdf0e10cSrcweir /*****************************************************************************/
1595cdf0e10cSrcweir /* osl_getFamilyOfSocketAddr */
1596cdf0e10cSrcweir /*****************************************************************************/
osl_getFamilyOfSocketAddr(oslSocketAddr pAddr)1597cdf0e10cSrcweir oslAddrFamily SAL_CALL osl_getFamilyOfSocketAddr(oslSocketAddr pAddr)
1598cdf0e10cSrcweir {
1599cdf0e10cSrcweir OSL_ASSERT(pAddr);
1600cdf0e10cSrcweir
1601cdf0e10cSrcweir if (pAddr)
1602cdf0e10cSrcweir return FAMILY_FROM_NATIVE(pAddr->m_sockaddr.sa_family);
1603cdf0e10cSrcweir else
1604cdf0e10cSrcweir return osl_Socket_FamilyInvalid;
1605cdf0e10cSrcweir }
1606cdf0e10cSrcweir
1607cdf0e10cSrcweir /*****************************************************************************/
1608cdf0e10cSrcweir /* osl_getInetPortOfSocketAddr */
1609cdf0e10cSrcweir /*****************************************************************************/
osl_getInetPortOfSocketAddr(oslSocketAddr pAddr)1610cdf0e10cSrcweir sal_Int32 SAL_CALL osl_getInetPortOfSocketAddr(oslSocketAddr pAddr)
1611cdf0e10cSrcweir {
1612cdf0e10cSrcweir OSL_ASSERT(pAddr);
1613cdf0e10cSrcweir if( pAddr )
1614cdf0e10cSrcweir {
1615cdf0e10cSrcweir struct sockaddr_in* pSystemInetAddr= (struct sockaddr_in*)&(pAddr->m_sockaddr);
1616cdf0e10cSrcweir
1617cdf0e10cSrcweir if ( pSystemInetAddr->sin_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
1618cdf0e10cSrcweir return ntohs(pSystemInetAddr->sin_port);
1619cdf0e10cSrcweir }
1620cdf0e10cSrcweir return OSL_INVALID_PORT;
1621cdf0e10cSrcweir }
1622cdf0e10cSrcweir
1623cdf0e10cSrcweir /*****************************************************************************/
1624cdf0e10cSrcweir /* osl_setInetPortOfSocketAddr */
1625cdf0e10cSrcweir /*****************************************************************************/
osl_setInetPortOfSocketAddr(oslSocketAddr pAddr,sal_Int32 Port)1626cdf0e10cSrcweir sal_Bool SAL_CALL osl_setInetPortOfSocketAddr(oslSocketAddr pAddr, sal_Int32 Port)
1627cdf0e10cSrcweir {
1628cdf0e10cSrcweir OSL_ASSERT(pAddr);
1629cdf0e10cSrcweir if( pAddr )
1630cdf0e10cSrcweir {
1631cdf0e10cSrcweir struct sockaddr_in* pSystemInetAddr= (struct sockaddr_in*)&(pAddr->m_sockaddr);
1632cdf0e10cSrcweir if ( pSystemInetAddr->sin_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
1633cdf0e10cSrcweir {
1634cdf0e10cSrcweir pSystemInetAddr->sin_port= htons((short)Port);
1635cdf0e10cSrcweir return sal_True;
1636cdf0e10cSrcweir }
1637cdf0e10cSrcweir }
1638cdf0e10cSrcweir
1639cdf0e10cSrcweir /* this is not a inet-addr => can't set port */
1640cdf0e10cSrcweir return sal_False;
1641cdf0e10cSrcweir }
1642cdf0e10cSrcweir
1643cdf0e10cSrcweir /*****************************************************************************/
1644cdf0e10cSrcweir /* osl_getHostnameOfSocketAddr */
1645cdf0e10cSrcweir /*****************************************************************************/
osl_getHostnameOfSocketAddr(oslSocketAddr Addr,rtl_uString ** ustrHostname)1646cdf0e10cSrcweir oslSocketResult SAL_CALL osl_getHostnameOfSocketAddr(oslSocketAddr Addr, rtl_uString **ustrHostname)
1647cdf0e10cSrcweir {
1648cdf0e10cSrcweir oslSocketResult Result;
1649cdf0e10cSrcweir sal_Char pszHostname[1024];
1650cdf0e10cSrcweir
1651cdf0e10cSrcweir pszHostname[0] = '\0';
1652cdf0e10cSrcweir
1653cdf0e10cSrcweir Result = osl_psz_getHostnameOfSocketAddr(Addr,pszHostname,sizeof(pszHostname));
1654cdf0e10cSrcweir
1655cdf0e10cSrcweir rtl_uString_newFromAscii(ustrHostname,pszHostname);
1656cdf0e10cSrcweir
1657cdf0e10cSrcweir return Result;
1658cdf0e10cSrcweir }
1659cdf0e10cSrcweir
1660cdf0e10cSrcweir
osl_psz_getHostnameOfSocketAddr(oslSocketAddr pAddr,sal_Char * pBuffer,sal_uInt32 BufferSize)1661cdf0e10cSrcweir oslSocketResult SAL_CALL osl_psz_getHostnameOfSocketAddr(oslSocketAddr pAddr,
1662cdf0e10cSrcweir sal_Char *pBuffer, sal_uInt32 BufferSize)
1663cdf0e10cSrcweir {
1664cdf0e10cSrcweir oslHostAddr pHostAddr= (oslHostAddr )osl_createHostAddrByAddr(pAddr);
1665cdf0e10cSrcweir
1666cdf0e10cSrcweir if (pHostAddr)
1667cdf0e10cSrcweir {
1668cdf0e10cSrcweir strncpy(pBuffer, pHostAddr->pHostName, BufferSize);
1669cdf0e10cSrcweir
1670cdf0e10cSrcweir pBuffer[BufferSize - 1] = '\0';
1671cdf0e10cSrcweir
1672cdf0e10cSrcweir osl_destroyHostAddr(pHostAddr);
1673cdf0e10cSrcweir
1674cdf0e10cSrcweir return osl_Socket_Ok;
1675cdf0e10cSrcweir }
1676cdf0e10cSrcweir
1677cdf0e10cSrcweir return osl_Socket_Error;
1678cdf0e10cSrcweir }
1679cdf0e10cSrcweir
1680cdf0e10cSrcweir /*****************************************************************************/
1681cdf0e10cSrcweir /* osl_getDottedInetAddrOfSocketAddr */
1682cdf0e10cSrcweir /*****************************************************************************/
osl_getDottedInetAddrOfSocketAddr(oslSocketAddr Addr,rtl_uString ** ustrDottedInetAddr)1683cdf0e10cSrcweir oslSocketResult SAL_CALL osl_getDottedInetAddrOfSocketAddr(oslSocketAddr Addr, rtl_uString **ustrDottedInetAddr)
1684cdf0e10cSrcweir {
1685cdf0e10cSrcweir oslSocketResult Result;
1686cdf0e10cSrcweir sal_Char pszDottedInetAddr[1024];
1687cdf0e10cSrcweir
1688cdf0e10cSrcweir pszDottedInetAddr[0] = '\0';
1689cdf0e10cSrcweir
1690cdf0e10cSrcweir Result = osl_psz_getDottedInetAddrOfSocketAddr(Addr,pszDottedInetAddr,sizeof(pszDottedInetAddr));
1691cdf0e10cSrcweir
1692cdf0e10cSrcweir rtl_uString_newFromAscii(ustrDottedInetAddr,pszDottedInetAddr);
1693cdf0e10cSrcweir
1694cdf0e10cSrcweir return Result;
1695cdf0e10cSrcweir
1696cdf0e10cSrcweir }
1697cdf0e10cSrcweir
osl_psz_getDottedInetAddrOfSocketAddr(oslSocketAddr pAddr,sal_Char * pBuffer,sal_uInt32 BufferSize)1698cdf0e10cSrcweir oslSocketResult SAL_CALL osl_psz_getDottedInetAddrOfSocketAddr(oslSocketAddr pAddr,
1699cdf0e10cSrcweir sal_Char *pBuffer, sal_uInt32 BufferSize)
1700cdf0e10cSrcweir {
1701cdf0e10cSrcweir OSL_ASSERT(pAddr);
1702cdf0e10cSrcweir
1703cdf0e10cSrcweir if( pAddr )
1704cdf0e10cSrcweir {
1705cdf0e10cSrcweir struct sockaddr_in* pSystemInetAddr = ( struct sockaddr_in * ) &(pAddr->m_sockaddr);
1706cdf0e10cSrcweir
1707cdf0e10cSrcweir if (pSystemInetAddr->sin_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
1708cdf0e10cSrcweir {
1709cdf0e10cSrcweir strncpy(pBuffer, inet_ntoa(pSystemInetAddr->sin_addr), BufferSize);
1710cdf0e10cSrcweir pBuffer[BufferSize - 1] = '\0';
1711cdf0e10cSrcweir
1712cdf0e10cSrcweir return osl_Socket_Ok;
1713cdf0e10cSrcweir }
1714cdf0e10cSrcweir }
1715cdf0e10cSrcweir
1716cdf0e10cSrcweir return osl_Socket_Error;
1717cdf0e10cSrcweir }
1718cdf0e10cSrcweir
1719cdf0e10cSrcweir #if 0 /* OBSOLETE */
1720cdf0e10cSrcweir /*****************************************************************************/
1721cdf0e10cSrcweir /* osl_getIpxNetNumber */
1722cdf0e10cSrcweir /*****************************************************************************/
1723cdf0e10cSrcweir oslSocketResult SAL_CALL osl_getIpxNetNumber(oslSocketAddr Addr,
1724cdf0e10cSrcweir oslSocketIpxNetNumber NetNumber)
1725cdf0e10cSrcweir
1726cdf0e10cSrcweir {
1727cdf0e10cSrcweir struct sockaddr_ipx* pAddr;
1728cdf0e10cSrcweir
1729cdf0e10cSrcweir pAddr= (struct sockaddr_ipx*)Addr;
1730cdf0e10cSrcweir
1731cdf0e10cSrcweir OSL_ASSERT(pAddr);
1732cdf0e10cSrcweir
1733cdf0e10cSrcweir if (pAddr && (pAddr->sa_family == FAMILY_TO_NATIVE(osl_Socket_FamilyIpx)))
1734cdf0e10cSrcweir {
1735cdf0e10cSrcweir memcpy(NetNumber, pAddr->sa_netnum, sizeof(NetNumber));
1736cdf0e10cSrcweir
1737cdf0e10cSrcweir return osl_Socket_Ok;
1738cdf0e10cSrcweir }
1739cdf0e10cSrcweir else
1740cdf0e10cSrcweir return osl_Socket_Error;
1741cdf0e10cSrcweir }
1742cdf0e10cSrcweir
1743cdf0e10cSrcweir
1744cdf0e10cSrcweir /*****************************************************************************/
1745cdf0e10cSrcweir /* osl_getIpxNodeNumber */
1746cdf0e10cSrcweir /*****************************************************************************/
1747cdf0e10cSrcweir oslSocketResult SAL_CALL osl_getIpxNodeNumber(oslSocketAddr Addr,
1748cdf0e10cSrcweir oslSocketIpxNodeNumber NodeNumber)
1749cdf0e10cSrcweir
1750cdf0e10cSrcweir {
1751cdf0e10cSrcweir struct sockaddr_ipx* pAddr;
1752cdf0e10cSrcweir
1753cdf0e10cSrcweir pAddr= (struct sockaddr_ipx*)Addr;
1754cdf0e10cSrcweir
1755cdf0e10cSrcweir OSL_ASSERT(pAddr);
1756cdf0e10cSrcweir
1757cdf0e10cSrcweir if (pAddr && (pAddr->sa_family == FAMILY_TO_NATIVE(osl_Socket_FamilyIpx)))
1758cdf0e10cSrcweir {
1759cdf0e10cSrcweir memcpy(NodeNumber, pAddr->sa_nodenum, sizeof(NodeNumber));
1760cdf0e10cSrcweir
1761cdf0e10cSrcweir return osl_Socket_Ok;
1762cdf0e10cSrcweir }
1763cdf0e10cSrcweir else
1764cdf0e10cSrcweir return osl_Socket_Error;
1765cdf0e10cSrcweir }
1766cdf0e10cSrcweir
1767cdf0e10cSrcweir
1768cdf0e10cSrcweir /*****************************************************************************/
1769cdf0e10cSrcweir /* osl_getIpxSocketNumber */
1770cdf0e10cSrcweir /*****************************************************************************/
1771cdf0e10cSrcweir sal_Int32 SAL_CALL osl_getIpxSocketNumber(oslSocketAddr Addr)
1772cdf0e10cSrcweir {
1773cdf0e10cSrcweir struct sockaddr_ipx* pAddr= (struct sockaddr_ipx*)Addr;
1774cdf0e10cSrcweir OSL_ASSERT(pAddr);
1775cdf0e10cSrcweir
1776cdf0e10cSrcweir if (pAddr && (pAddr->sa_family == FAMILY_TO_NATIVE(osl_Socket_FamilyIpx)))
1777cdf0e10cSrcweir return pAddr->sa_socket;
1778cdf0e10cSrcweir else
1779cdf0e10cSrcweir return OSL_INVALID_IPX_SOCKET_NO;
1780cdf0e10cSrcweir }
1781cdf0e10cSrcweir
1782cdf0e10cSrcweir #endif /* OBSOLETE */
1783cdf0e10cSrcweir
1784cdf0e10cSrcweir /*****************************************************************************/
1785cdf0e10cSrcweir /* osl_createSocket */
1786cdf0e10cSrcweir /*****************************************************************************/
osl_createSocket(oslAddrFamily Family,oslSocketType Type,oslProtocol Protocol)1787cdf0e10cSrcweir oslSocket SAL_CALL osl_createSocket(oslAddrFamily Family,
1788cdf0e10cSrcweir oslSocketType Type,
1789cdf0e10cSrcweir oslProtocol Protocol)
1790cdf0e10cSrcweir {
1791cdf0e10cSrcweir int Flags;
1792cdf0e10cSrcweir oslSocket pSocket;
1793cdf0e10cSrcweir
1794cdf0e10cSrcweir /* alloc memory */
1795cdf0e10cSrcweir pSocket= __osl_createSocketImpl(OSL_INVALID_SOCKET);
1796cdf0e10cSrcweir
1797cdf0e10cSrcweir /* create socket */
1798cdf0e10cSrcweir pSocket->m_Socket= socket(FAMILY_TO_NATIVE(Family),
1799cdf0e10cSrcweir TYPE_TO_NATIVE(Type),
1800cdf0e10cSrcweir PROTOCOL_TO_NATIVE(Protocol));
1801cdf0e10cSrcweir
1802cdf0e10cSrcweir /* creation failed => free memory */
1803cdf0e10cSrcweir if(pSocket->m_Socket == OSL_INVALID_SOCKET)
1804cdf0e10cSrcweir {
1805cdf0e10cSrcweir OSL_TRACE("osl_createSocket failed. Errno: %d; %s\n",
1806cdf0e10cSrcweir errno,
1807cdf0e10cSrcweir strerror(errno));
1808cdf0e10cSrcweir
1809cdf0e10cSrcweir __osl_destroySocketImpl((pSocket));
1810cdf0e10cSrcweir pSocket= 0;
1811cdf0e10cSrcweir }
1812cdf0e10cSrcweir else
1813cdf0e10cSrcweir {
1814cdf0e10cSrcweir /* set close-on-exec flag */
1815cdf0e10cSrcweir if ((Flags = fcntl(pSocket->m_Socket, F_GETFD, 0)) != -1)
1816cdf0e10cSrcweir {
1817cdf0e10cSrcweir Flags |= FD_CLOEXEC;
1818cdf0e10cSrcweir if (fcntl(pSocket->m_Socket, F_SETFD, Flags) == -1)
1819cdf0e10cSrcweir {
1820cdf0e10cSrcweir pSocket->m_nLastError=errno;
1821cdf0e10cSrcweir OSL_TRACE("osl_createSocket failed changing socket flags. Errno: %d; %s\n",
1822cdf0e10cSrcweir errno,
1823cdf0e10cSrcweir strerror(errno));
1824cdf0e10cSrcweir }
1825cdf0e10cSrcweir }
1826cdf0e10cSrcweir else
1827cdf0e10cSrcweir {
1828cdf0e10cSrcweir pSocket->m_nLastError=errno;
1829cdf0e10cSrcweir }
1830cdf0e10cSrcweir
1831cdf0e10cSrcweir
1832cdf0e10cSrcweir pSocket->m_CloseCallback = NULL;
1833cdf0e10cSrcweir pSocket->m_CallbackArg = NULL;
1834cdf0e10cSrcweir }
1835cdf0e10cSrcweir
1836cdf0e10cSrcweir return pSocket;
1837cdf0e10cSrcweir }
1838cdf0e10cSrcweir
osl_acquireSocket(oslSocket pSocket)1839cdf0e10cSrcweir void SAL_CALL osl_acquireSocket(oslSocket pSocket)
1840cdf0e10cSrcweir {
1841cdf0e10cSrcweir osl_incrementInterlockedCount( &(pSocket->m_nRefCount ) );
1842cdf0e10cSrcweir }
1843cdf0e10cSrcweir
osl_releaseSocket(oslSocket pSocket)1844cdf0e10cSrcweir void SAL_CALL osl_releaseSocket( oslSocket pSocket )
1845cdf0e10cSrcweir {
1846cdf0e10cSrcweir if( pSocket && 0 == osl_decrementInterlockedCount( &(pSocket->m_nRefCount) ) )
1847cdf0e10cSrcweir {
1848cdf0e10cSrcweir #if defined(LINUX)
1849cdf0e10cSrcweir if ( pSocket->m_bIsAccepting == sal_True )
1850cdf0e10cSrcweir {
1851cdf0e10cSrcweir OSL_ENSURE(0, "osl_destroySocket : attempt to destroy socket while accepting\n");
1852cdf0e10cSrcweir return;
1853cdf0e10cSrcweir }
1854cdf0e10cSrcweir #endif /* LINUX */
1855cdf0e10cSrcweir osl_closeSocket( pSocket );
1856cdf0e10cSrcweir __osl_destroySocketImpl( pSocket );
1857cdf0e10cSrcweir }
1858cdf0e10cSrcweir }
1859cdf0e10cSrcweir
1860cdf0e10cSrcweir
1861cdf0e10cSrcweir
1862cdf0e10cSrcweir /*****************************************************************************/
1863cdf0e10cSrcweir /* osl_closeSocket */
1864cdf0e10cSrcweir /*****************************************************************************/
osl_closeSocket(oslSocket pSocket)1865cdf0e10cSrcweir void SAL_CALL osl_closeSocket(oslSocket pSocket)
1866cdf0e10cSrcweir {
1867cdf0e10cSrcweir int nRet;
1868cdf0e10cSrcweir int nFD;
1869cdf0e10cSrcweir
1870cdf0e10cSrcweir /* socket already invalid */
1871cdf0e10cSrcweir if(pSocket==0)
1872cdf0e10cSrcweir return;
1873cdf0e10cSrcweir
1874cdf0e10cSrcweir pSocket->m_nLastError=0;
1875cdf0e10cSrcweir nFD = pSocket->m_Socket;
1876cdf0e10cSrcweir
1877cdf0e10cSrcweir pSocket->m_Socket = OSL_INVALID_SOCKET;
1878cdf0e10cSrcweir
1879cdf0e10cSrcweir #if defined(LINUX)
1880cdf0e10cSrcweir pSocket->m_bIsInShutdown = sal_True;
1881cdf0e10cSrcweir
1882cdf0e10cSrcweir if ( pSocket->m_bIsAccepting == sal_True )
1883cdf0e10cSrcweir {
1884cdf0e10cSrcweir int nConnFD;
1885cdf0e10cSrcweir struct sockaddr aSockAddr;
1886cdf0e10cSrcweir socklen_t nSockLen = sizeof(aSockAddr);
1887cdf0e10cSrcweir
1888cdf0e10cSrcweir nRet = getsockname(nFD, &aSockAddr, &nSockLen);
1889cdf0e10cSrcweir #if OSL_DEBUG_LEVEL > 1
1890cdf0e10cSrcweir if ( nRet < 0 )
1891cdf0e10cSrcweir {
1892cdf0e10cSrcweir perror("getsockname");
1893cdf0e10cSrcweir }
1894cdf0e10cSrcweir #endif /* OSL_DEBUG_LEVEL */
1895cdf0e10cSrcweir
1896cdf0e10cSrcweir if ( aSockAddr.sa_family == AF_INET )
1897cdf0e10cSrcweir {
1898cdf0e10cSrcweir struct sockaddr_in* pSockAddrIn = (struct sockaddr_in*) &aSockAddr;
1899cdf0e10cSrcweir
1900cdf0e10cSrcweir if ( pSockAddrIn->sin_addr.s_addr == htonl(INADDR_ANY) )
1901cdf0e10cSrcweir {
1902cdf0e10cSrcweir pSockAddrIn->sin_addr.s_addr = htonl(INADDR_LOOPBACK);
1903cdf0e10cSrcweir }
1904cdf0e10cSrcweir
1905cdf0e10cSrcweir nConnFD = socket(AF_INET, SOCK_STREAM, 0);
1906cdf0e10cSrcweir #if OSL_DEBUG_LEVEL > 1
1907cdf0e10cSrcweir if ( nConnFD < 0 )
1908cdf0e10cSrcweir {
1909cdf0e10cSrcweir perror("socket");
1910cdf0e10cSrcweir }
1911cdf0e10cSrcweir #endif /* OSL_DEBUG_LEVEL */
1912cdf0e10cSrcweir
1913cdf0e10cSrcweir nRet = connect(nConnFD, &aSockAddr, sizeof(aSockAddr));
1914cdf0e10cSrcweir #if OSL_DEBUG_LEVEL > 1
1915cdf0e10cSrcweir if ( nRet < 0 )
1916cdf0e10cSrcweir {
1917cdf0e10cSrcweir perror("connect");
1918cdf0e10cSrcweir }
1919cdf0e10cSrcweir #endif /* OSL_DEBUG_LEVEL */
1920cdf0e10cSrcweir close(nConnFD);
1921cdf0e10cSrcweir }
1922cdf0e10cSrcweir }
1923cdf0e10cSrcweir #endif /* LINUX */
1924cdf0e10cSrcweir
1925cdf0e10cSrcweir /* registrierten Callback ausfuehren */
1926cdf0e10cSrcweir if (pSocket->m_CloseCallback != NULL)
1927cdf0e10cSrcweir {
1928cdf0e10cSrcweir pSocket->m_CloseCallback(pSocket->m_CallbackArg);
1929cdf0e10cSrcweir }
1930cdf0e10cSrcweir
1931cdf0e10cSrcweir nRet=close(nFD);
1932cdf0e10cSrcweir if ( nRet != 0 )
1933cdf0e10cSrcweir {
1934cdf0e10cSrcweir pSocket->m_nLastError=errno;
1935cdf0e10cSrcweir OSL_TRACE("closeSocket close error '%s'\n",strerror(errno));
1936cdf0e10cSrcweir }
1937cdf0e10cSrcweir
1938cdf0e10cSrcweir pSocket->m_Socket = OSL_INVALID_SOCKET;
1939cdf0e10cSrcweir }
1940cdf0e10cSrcweir
1941cdf0e10cSrcweir /*****************************************************************************/
1942cdf0e10cSrcweir /* osl_getLocalAddrOfSocket */
1943cdf0e10cSrcweir /* Note that I rely on the fact that oslSocketAddr and struct sockaddr */
1944cdf0e10cSrcweir /* are the same! I don't like it very much but see no other easy way to conceal */
1945cdf0e10cSrcweir /* the struct sockaddr from the eyes of the user. */
1946cdf0e10cSrcweir /*****************************************************************************/
osl_getLocalAddrOfSocket(oslSocket pSocket)1947cdf0e10cSrcweir oslSocketAddr SAL_CALL osl_getLocalAddrOfSocket(oslSocket pSocket)
1948cdf0e10cSrcweir {
1949cdf0e10cSrcweir #if defined(LINUX) || defined(FREEBSD)
1950cdf0e10cSrcweir socklen_t AddrLen;
1951cdf0e10cSrcweir #else
1952cdf0e10cSrcweir /* mfe: Solaris 'cc +w' means Addrlen should be signed! */
1953cdf0e10cSrcweir /* it's really defined as 'int*' in /usr/include/sys/socket.h! */
1954cdf0e10cSrcweir /* the man page says it expects a 'size_t' */
1955cdf0e10cSrcweir int AddrLen;
1956cdf0e10cSrcweir #endif
1957cdf0e10cSrcweir struct sockaddr Addr;
1958cdf0e10cSrcweir oslSocketAddr pAddr;
1959cdf0e10cSrcweir
1960cdf0e10cSrcweir if (pSocket == NULL) /* ENOTSOCK */
1961cdf0e10cSrcweir return ((oslSocketAddr)NULL);
1962cdf0e10cSrcweir
1963cdf0e10cSrcweir AddrLen= sizeof(struct sockaddr);
1964cdf0e10cSrcweir
1965cdf0e10cSrcweir if (getsockname(pSocket->m_Socket, &Addr, PTR_SIZE_T(AddrLen)) == OSL_SOCKET_ERROR)
1966cdf0e10cSrcweir return ((oslSocketAddr)NULL);
1967cdf0e10cSrcweir
1968cdf0e10cSrcweir pAddr = __osl_createSocketAddrFromSystem( &Addr );
1969cdf0e10cSrcweir return pAddr;
1970cdf0e10cSrcweir }
1971cdf0e10cSrcweir
1972cdf0e10cSrcweir /*****************************************************************************/
1973cdf0e10cSrcweir /* osl_getPeerAddrOfSocket */
1974cdf0e10cSrcweir /*****************************************************************************/
osl_getPeerAddrOfSocket(oslSocket pSocket)1975cdf0e10cSrcweir oslSocketAddr SAL_CALL osl_getPeerAddrOfSocket(oslSocket pSocket)
1976cdf0e10cSrcweir {
1977cdf0e10cSrcweir sal_uInt32 AddrLen;
1978cdf0e10cSrcweir struct sockaddr Addr;
1979cdf0e10cSrcweir
1980cdf0e10cSrcweir OSL_ASSERT(pSocket);
1981cdf0e10cSrcweir if ( pSocket == 0 )
1982cdf0e10cSrcweir {
1983cdf0e10cSrcweir return 0;
1984cdf0e10cSrcweir }
1985cdf0e10cSrcweir
1986cdf0e10cSrcweir pSocket->m_nLastError=0;
1987cdf0e10cSrcweir AddrLen= sizeof(struct sockaddr);
1988cdf0e10cSrcweir
1989cdf0e10cSrcweir if(getpeername(pSocket->m_Socket, &Addr, (int*)PTR_SIZE_T(AddrLen)) == OSL_SOCKET_ERROR)
1990cdf0e10cSrcweir {
1991cdf0e10cSrcweir pSocket->m_nLastError=errno;
1992cdf0e10cSrcweir return 0;
1993cdf0e10cSrcweir }
1994cdf0e10cSrcweir return __osl_createSocketAddrFromSystem( &Addr );
1995cdf0e10cSrcweir }
1996cdf0e10cSrcweir
1997cdf0e10cSrcweir /*****************************************************************************/
1998cdf0e10cSrcweir /* osl_bindAddrToSocket */
1999cdf0e10cSrcweir /*****************************************************************************/
osl_bindAddrToSocket(oslSocket pSocket,oslSocketAddr pAddr)2000cdf0e10cSrcweir sal_Bool SAL_CALL osl_bindAddrToSocket(oslSocket pSocket,
2001cdf0e10cSrcweir oslSocketAddr pAddr)
2002cdf0e10cSrcweir {
2003cdf0e10cSrcweir int nRet;
2004cdf0e10cSrcweir
2005cdf0e10cSrcweir OSL_ASSERT(pSocket && pAddr );
2006cdf0e10cSrcweir if ( pSocket == 0 || pAddr == 0 )
2007cdf0e10cSrcweir {
2008cdf0e10cSrcweir return sal_False;
2009cdf0e10cSrcweir }
2010cdf0e10cSrcweir
2011cdf0e10cSrcweir pSocket->m_nLastError=0;
2012cdf0e10cSrcweir
2013cdf0e10cSrcweir nRet = bind(pSocket->m_Socket, &(pAddr->m_sockaddr), sizeof(struct sockaddr));
2014cdf0e10cSrcweir
2015cdf0e10cSrcweir if ( nRet == OSL_SOCKET_ERROR)
2016cdf0e10cSrcweir {
2017cdf0e10cSrcweir pSocket->m_nLastError=errno;
2018cdf0e10cSrcweir return sal_False;
2019cdf0e10cSrcweir }
2020cdf0e10cSrcweir
2021cdf0e10cSrcweir return sal_True;
2022cdf0e10cSrcweir }
2023cdf0e10cSrcweir
2024cdf0e10cSrcweir
2025cdf0e10cSrcweir /*****************************************************************************/
2026cdf0e10cSrcweir /* osl_listenOnSocket */
2027cdf0e10cSrcweir /*****************************************************************************/
osl_listenOnSocket(oslSocket pSocket,sal_Int32 MaxPendingConnections)2028cdf0e10cSrcweir sal_Bool SAL_CALL osl_listenOnSocket(oslSocket pSocket,
2029cdf0e10cSrcweir sal_Int32 MaxPendingConnections)
2030cdf0e10cSrcweir {
2031cdf0e10cSrcweir int nRet;
2032cdf0e10cSrcweir
2033cdf0e10cSrcweir OSL_ASSERT(pSocket);
2034cdf0e10cSrcweir if ( pSocket == 0 )
2035cdf0e10cSrcweir {
2036cdf0e10cSrcweir return sal_False;
2037cdf0e10cSrcweir }
2038cdf0e10cSrcweir
2039cdf0e10cSrcweir pSocket->m_nLastError=0;
2040cdf0e10cSrcweir
2041cdf0e10cSrcweir nRet = listen(pSocket->m_Socket,
2042cdf0e10cSrcweir MaxPendingConnections == -1 ?
2043cdf0e10cSrcweir SOMAXCONN :
2044cdf0e10cSrcweir MaxPendingConnections);
2045cdf0e10cSrcweir if ( nRet == OSL_SOCKET_ERROR)
2046cdf0e10cSrcweir {
2047cdf0e10cSrcweir pSocket->m_nLastError=errno;
2048cdf0e10cSrcweir return sal_False;
2049cdf0e10cSrcweir }
2050cdf0e10cSrcweir
2051cdf0e10cSrcweir return sal_True;
2052cdf0e10cSrcweir }
2053cdf0e10cSrcweir
2054cdf0e10cSrcweir
2055cdf0e10cSrcweir /*****************************************************************************/
2056cdf0e10cSrcweir /* osl_connectSocketTo */
2057cdf0e10cSrcweir /*****************************************************************************/
osl_connectSocketTo(oslSocket pSocket,oslSocketAddr pAddr,const TimeValue * pTimeout)2058cdf0e10cSrcweir oslSocketResult SAL_CALL osl_connectSocketTo(oslSocket pSocket,
2059cdf0e10cSrcweir oslSocketAddr pAddr,
2060cdf0e10cSrcweir const TimeValue* pTimeout)
2061cdf0e10cSrcweir {
2062cdf0e10cSrcweir fd_set WriteSet;
2063cdf0e10cSrcweir fd_set ExcptSet;
2064cdf0e10cSrcweir int ReadyHandles;
2065cdf0e10cSrcweir struct timeval tv;
2066cdf0e10cSrcweir oslSocketResult Result= osl_Socket_Ok;
2067cdf0e10cSrcweir
2068cdf0e10cSrcweir OSL_PRECOND(pSocket, "osl_connectSocketTo(): need a valid socket!\n");
2069cdf0e10cSrcweir
2070cdf0e10cSrcweir if ( pSocket == 0 )
2071cdf0e10cSrcweir {
2072cdf0e10cSrcweir return osl_Socket_Error;
2073cdf0e10cSrcweir }
2074cdf0e10cSrcweir
2075cdf0e10cSrcweir pSocket->m_nLastError=0;
2076cdf0e10cSrcweir
2077cdf0e10cSrcweir if (osl_isNonBlockingMode(pSocket))
2078cdf0e10cSrcweir {
2079cdf0e10cSrcweir if (connect(pSocket->m_Socket,
2080cdf0e10cSrcweir &(pAddr->m_sockaddr),
2081cdf0e10cSrcweir sizeof(struct sockaddr)) != OSL_SOCKET_ERROR)
2082cdf0e10cSrcweir return osl_Socket_Ok;
2083cdf0e10cSrcweir else
2084cdf0e10cSrcweir if (errno == EWOULDBLOCK || errno == EINPROGRESS)
2085cdf0e10cSrcweir {
2086cdf0e10cSrcweir pSocket->m_nLastError=EINPROGRESS;
2087cdf0e10cSrcweir return osl_Socket_InProgress;
2088cdf0e10cSrcweir }
2089cdf0e10cSrcweir
2090cdf0e10cSrcweir
2091cdf0e10cSrcweir pSocket->m_nLastError=errno;
2092cdf0e10cSrcweir OSL_TRACE("can't connect : '%s'",strerror(errno));
2093cdf0e10cSrcweir return osl_Socket_Error;
2094cdf0e10cSrcweir }
2095cdf0e10cSrcweir
2096cdf0e10cSrcweir /* set socket temporarily to non-blocking */
2097cdf0e10cSrcweir OSL_VERIFY(osl_enableNonBlockingMode(pSocket, sal_True));
2098cdf0e10cSrcweir
2099cdf0e10cSrcweir /* initiate connect */
2100cdf0e10cSrcweir if(connect(pSocket->m_Socket,
2101cdf0e10cSrcweir &(pAddr->m_sockaddr),
2102cdf0e10cSrcweir sizeof(struct sockaddr)) != OSL_SOCKET_ERROR)
2103cdf0e10cSrcweir {
2104cdf0e10cSrcweir /* immediate connection */
2105cdf0e10cSrcweir osl_enableNonBlockingMode(pSocket, sal_False);
2106cdf0e10cSrcweir
2107cdf0e10cSrcweir return osl_Socket_Ok;
2108cdf0e10cSrcweir }
2109cdf0e10cSrcweir else
2110cdf0e10cSrcweir {
2111cdf0e10cSrcweir /* really an error or just delayed? */
2112cdf0e10cSrcweir if (errno != EINPROGRESS)
2113cdf0e10cSrcweir {
2114cdf0e10cSrcweir pSocket->m_nLastError=errno;
2115cdf0e10cSrcweir OSL_TRACE(
2116cdf0e10cSrcweir "osl_connectSocketTo(): connect failed: errno: %d (%s)\n",
2117cdf0e10cSrcweir errno, strerror(errno));
2118cdf0e10cSrcweir
2119cdf0e10cSrcweir osl_enableNonBlockingMode(pSocket, sal_False);
2120cdf0e10cSrcweir return osl_Socket_Error;
2121cdf0e10cSrcweir }
2122cdf0e10cSrcweir }
2123cdf0e10cSrcweir
2124cdf0e10cSrcweir
2125cdf0e10cSrcweir /* prepare select set for socket */
2126cdf0e10cSrcweir FD_ZERO(&WriteSet);
2127cdf0e10cSrcweir FD_ZERO(&ExcptSet);
2128cdf0e10cSrcweir FD_SET(pSocket->m_Socket, &WriteSet);
2129cdf0e10cSrcweir FD_SET(pSocket->m_Socket, &ExcptSet);
2130cdf0e10cSrcweir
2131cdf0e10cSrcweir /* prepare timeout */
2132cdf0e10cSrcweir if (pTimeout)
2133cdf0e10cSrcweir {
2134cdf0e10cSrcweir /* divide milliseconds into seconds and microseconds */
2135cdf0e10cSrcweir tv.tv_sec= pTimeout->Seconds;
2136cdf0e10cSrcweir tv.tv_usec= pTimeout->Nanosec / 1000L;
2137cdf0e10cSrcweir }
2138cdf0e10cSrcweir
2139cdf0e10cSrcweir /* select */
2140cdf0e10cSrcweir ReadyHandles= select(pSocket->m_Socket+1,
2141cdf0e10cSrcweir 0,
2142cdf0e10cSrcweir PTR_FD_SET(WriteSet),
2143cdf0e10cSrcweir PTR_FD_SET(ExcptSet),
2144cdf0e10cSrcweir (pTimeout) ? &tv : 0);
2145cdf0e10cSrcweir
2146cdf0e10cSrcweir if (ReadyHandles > 0) /* connected */
2147cdf0e10cSrcweir {
2148cdf0e10cSrcweir if ( FD_ISSET(pSocket->m_Socket, &WriteSet ) )
2149cdf0e10cSrcweir {
2150cdf0e10cSrcweir int nErrorCode = 0;
2151cdf0e10cSrcweir #ifdef SOLARIS
2152cdf0e10cSrcweir /* mfe: Solaris 'cc +w' means 5th argument should be a 'int*'!
2153cdf0e10cSrcweir it's really defined as 'int*' in /usr/include/sys/socket.h!
2154cdf0e10cSrcweir the man page says it expects a 'size_t*'
2155cdf0e10cSrcweir */
2156cdf0e10cSrcweir int nErrorSize = sizeof( nErrorCode );
2157cdf0e10cSrcweir #else
2158cdf0e10cSrcweir size_t nErrorSize = sizeof( nErrorCode );
2159cdf0e10cSrcweir #endif
2160cdf0e10cSrcweir
2161cdf0e10cSrcweir int nSockOpt;
2162cdf0e10cSrcweir
2163cdf0e10cSrcweir nSockOpt = getsockopt ( pSocket->m_Socket, SOL_SOCKET, SO_ERROR,
2164cdf0e10cSrcweir #ifdef SOLARIS
2165cdf0e10cSrcweir /* mfe: Solaris 'cc +w' means 4th argument should be a 'char*'!
2166cdf0e10cSrcweir it's really defined as 'char*' in /usr/include/sys/socket.h!
2167cdf0e10cSrcweir the man page says it expects a 'void*'
2168cdf0e10cSrcweir */
2169cdf0e10cSrcweir (char*)
2170cdf0e10cSrcweir #endif
2171cdf0e10cSrcweir &nErrorCode, (int*)&nErrorSize );
2172cdf0e10cSrcweir if ( (nSockOpt == 0) && (nErrorCode == 0))
2173cdf0e10cSrcweir Result = osl_Socket_Ok;
2174cdf0e10cSrcweir else
2175cdf0e10cSrcweir Result = osl_Socket_Error;
2176cdf0e10cSrcweir }
2177cdf0e10cSrcweir else
2178cdf0e10cSrcweir {
2179cdf0e10cSrcweir Result= osl_Socket_Error;
2180cdf0e10cSrcweir }
2181cdf0e10cSrcweir }
2182cdf0e10cSrcweir else if (ReadyHandles < 0) /* error */
2183cdf0e10cSrcweir {
2184cdf0e10cSrcweir if (errno == EBADF) /* most probably interrupted by close() */
2185cdf0e10cSrcweir {
2186cdf0e10cSrcweir /* do not access pSockImpl because it is about to be or */
2187cdf0e10cSrcweir /* already destroyed */
2188cdf0e10cSrcweir return osl_Socket_Interrupted;
2189cdf0e10cSrcweir }
2190cdf0e10cSrcweir else
2191cdf0e10cSrcweir {
2192cdf0e10cSrcweir pSocket->m_nLastError=errno;
2193cdf0e10cSrcweir Result= osl_Socket_Error;
2194cdf0e10cSrcweir }
2195cdf0e10cSrcweir }
2196cdf0e10cSrcweir else /* timeout */
2197cdf0e10cSrcweir {
2198cdf0e10cSrcweir pSocket->m_nLastError=errno;
2199cdf0e10cSrcweir Result= osl_Socket_TimedOut;
2200cdf0e10cSrcweir }
2201cdf0e10cSrcweir
2202cdf0e10cSrcweir osl_enableNonBlockingMode(pSocket, sal_False);
2203cdf0e10cSrcweir
2204cdf0e10cSrcweir return Result;
2205cdf0e10cSrcweir }
2206cdf0e10cSrcweir
2207cdf0e10cSrcweir
2208cdf0e10cSrcweir /*****************************************************************************/
2209cdf0e10cSrcweir /* osl_acceptConnectionOnSocket */
2210cdf0e10cSrcweir /*****************************************************************************/
osl_acceptConnectionOnSocket(oslSocket pSocket,oslSocketAddr * ppAddr)2211cdf0e10cSrcweir oslSocket SAL_CALL osl_acceptConnectionOnSocket(oslSocket pSocket,
2212cdf0e10cSrcweir oslSocketAddr* ppAddr)
2213cdf0e10cSrcweir {
2214cdf0e10cSrcweir struct sockaddr Addr;
2215cdf0e10cSrcweir int Connection, Flags;
2216cdf0e10cSrcweir sal_uInt32 AddrLen = sizeof(struct sockaddr);
2217cdf0e10cSrcweir oslSocket pConnectionSockImpl;
2218cdf0e10cSrcweir
2219cdf0e10cSrcweir OSL_ASSERT(pSocket);
2220cdf0e10cSrcweir if ( pSocket == 0 )
2221cdf0e10cSrcweir {
2222cdf0e10cSrcweir return 0;
2223cdf0e10cSrcweir }
2224cdf0e10cSrcweir
2225cdf0e10cSrcweir pSocket->m_nLastError=0;
2226cdf0e10cSrcweir #if defined(LINUX)
2227cdf0e10cSrcweir pSocket->m_bIsAccepting = sal_True;
2228cdf0e10cSrcweir #endif /* LINUX */
2229cdf0e10cSrcweir
2230cdf0e10cSrcweir if( ppAddr && *ppAddr )
2231cdf0e10cSrcweir {
2232cdf0e10cSrcweir osl_destroySocketAddr( *ppAddr );
2233cdf0e10cSrcweir *ppAddr = 0;
2234cdf0e10cSrcweir }
2235cdf0e10cSrcweir
2236cdf0e10cSrcweir /* prevent Linux EINTR behaviour */
2237cdf0e10cSrcweir do
2238cdf0e10cSrcweir {
2239cdf0e10cSrcweir Connection = accept(pSocket->m_Socket, &Addr, (int*)PTR_SIZE_T(AddrLen));
2240cdf0e10cSrcweir } while (Connection == -1 && errno == EINTR);
2241cdf0e10cSrcweir
2242cdf0e10cSrcweir
2243cdf0e10cSrcweir /* accept failed? */
2244cdf0e10cSrcweir if( Connection == OSL_SOCKET_ERROR )
2245cdf0e10cSrcweir {
2246cdf0e10cSrcweir pSocket->m_nLastError=errno;
2247cdf0e10cSrcweir OSL_TRACE("osl_acceptConnectionOnSocket : accept error '%s'\n",strerror(errno));
2248cdf0e10cSrcweir
2249cdf0e10cSrcweir #if defined(LINUX)
2250cdf0e10cSrcweir pSocket->m_bIsAccepting = sal_False;
2251cdf0e10cSrcweir #endif /* LINUX */
2252cdf0e10cSrcweir return 0;
2253cdf0e10cSrcweir }
2254cdf0e10cSrcweir
2255cdf0e10cSrcweir OSL_ASSERT(AddrLen == sizeof(struct sockaddr));
2256cdf0e10cSrcweir
2257cdf0e10cSrcweir
2258cdf0e10cSrcweir #if defined(LINUX)
2259cdf0e10cSrcweir if ( pSocket->m_bIsInShutdown == sal_True )
2260cdf0e10cSrcweir {
2261cdf0e10cSrcweir close(Connection);
2262cdf0e10cSrcweir OSL_TRACE("osl_acceptConnectionOnSocket : close while accept\n");
2263cdf0e10cSrcweir return 0;
2264cdf0e10cSrcweir }
2265cdf0e10cSrcweir #endif /* LINUX */
2266cdf0e10cSrcweir
2267cdf0e10cSrcweir
2268cdf0e10cSrcweir if(ppAddr)
2269cdf0e10cSrcweir {
2270cdf0e10cSrcweir *ppAddr= __osl_createSocketAddrFromSystem(&Addr);
2271cdf0e10cSrcweir }
2272cdf0e10cSrcweir
2273cdf0e10cSrcweir /* alloc memory */
2274cdf0e10cSrcweir pConnectionSockImpl= __osl_createSocketImpl(OSL_INVALID_SOCKET);
2275cdf0e10cSrcweir
2276cdf0e10cSrcweir /* set close-on-exec flag */
2277cdf0e10cSrcweir if ((Flags = fcntl(Connection, F_GETFD, 0)) != -1)
2278cdf0e10cSrcweir {
2279cdf0e10cSrcweir Flags |= FD_CLOEXEC;
2280cdf0e10cSrcweir if (fcntl(Connection, F_SETFD, Flags) == -1)
2281cdf0e10cSrcweir {
2282cdf0e10cSrcweir pSocket->m_nLastError=errno;
2283cdf0e10cSrcweir OSL_TRACE("osl_acceptConnectionOnSocket failed changing socket flags. Errno: %d (%s)\n",
2284cdf0e10cSrcweir errno,
2285cdf0e10cSrcweir strerror(errno));
2286cdf0e10cSrcweir }
2287cdf0e10cSrcweir
2288cdf0e10cSrcweir }
2289cdf0e10cSrcweir
2290cdf0e10cSrcweir pConnectionSockImpl->m_Socket = Connection;
2291cdf0e10cSrcweir pConnectionSockImpl->m_nLastError = 0;
2292cdf0e10cSrcweir pConnectionSockImpl->m_CloseCallback = NULL;
2293cdf0e10cSrcweir pConnectionSockImpl->m_CallbackArg = NULL;
2294cdf0e10cSrcweir #if defined(LINUX)
2295cdf0e10cSrcweir pConnectionSockImpl->m_bIsAccepting = sal_False;
2296cdf0e10cSrcweir
2297cdf0e10cSrcweir pSocket->m_bIsAccepting = sal_False;
2298cdf0e10cSrcweir #endif /* LINUX */
2299cdf0e10cSrcweir return pConnectionSockImpl;
2300cdf0e10cSrcweir }
2301cdf0e10cSrcweir
2302cdf0e10cSrcweir /*****************************************************************************/
2303cdf0e10cSrcweir /* osl_receiveSocket */
2304cdf0e10cSrcweir /*****************************************************************************/
osl_receiveSocket(oslSocket pSocket,void * pBuffer,sal_uInt32 BytesToRead,oslSocketMsgFlag Flag)2305cdf0e10cSrcweir sal_Int32 SAL_CALL osl_receiveSocket(oslSocket pSocket,
2306cdf0e10cSrcweir void* pBuffer,
2307cdf0e10cSrcweir sal_uInt32 BytesToRead,
2308cdf0e10cSrcweir oslSocketMsgFlag Flag)
2309cdf0e10cSrcweir {
2310cdf0e10cSrcweir int nRead;
2311cdf0e10cSrcweir
2312cdf0e10cSrcweir OSL_ASSERT(pSocket);
2313cdf0e10cSrcweir if ( pSocket == 0 )
2314cdf0e10cSrcweir {
2315cdf0e10cSrcweir OSL_TRACE("osl_receiveSocket : Invalid socket");
2316cdf0e10cSrcweir return -1;
2317cdf0e10cSrcweir }
2318cdf0e10cSrcweir
2319cdf0e10cSrcweir pSocket->m_nLastError=0;
2320cdf0e10cSrcweir
2321cdf0e10cSrcweir do
2322cdf0e10cSrcweir {
2323cdf0e10cSrcweir nRead = recv(pSocket->m_Socket,
2324cdf0e10cSrcweir (sal_Char*)pBuffer,
2325cdf0e10cSrcweir BytesToRead,
2326cdf0e10cSrcweir MSG_FLAG_TO_NATIVE(Flag));
2327cdf0e10cSrcweir } while ( nRead < 0 && errno == EINTR );
2328cdf0e10cSrcweir
2329cdf0e10cSrcweir if ( nRead < 0 )
2330cdf0e10cSrcweir {
2331cdf0e10cSrcweir pSocket->m_nLastError=errno;
2332cdf0e10cSrcweir OSL_TRACE("osl_receiveSocket failed : %i '%s'",nRead,strerror(errno));
2333cdf0e10cSrcweir }
2334cdf0e10cSrcweir else if ( nRead == 0 )
2335cdf0e10cSrcweir {
2336cdf0e10cSrcweir OSL_TRACE("osl_receiveSocket failed : %i '%s'",nRead,"EOL");
2337cdf0e10cSrcweir }
2338cdf0e10cSrcweir
2339cdf0e10cSrcweir return nRead;
2340cdf0e10cSrcweir }
2341cdf0e10cSrcweir
2342cdf0e10cSrcweir
2343cdf0e10cSrcweir /*****************************************************************************/
2344cdf0e10cSrcweir /* osl_receiveFromSocket */
2345cdf0e10cSrcweir /*****************************************************************************/
osl_receiveFromSocket(oslSocket pSocket,oslSocketAddr pSenderAddr,void * pBuffer,sal_uInt32 BufferSize,oslSocketMsgFlag Flag)2346cdf0e10cSrcweir sal_Int32 SAL_CALL osl_receiveFromSocket(oslSocket pSocket,
2347cdf0e10cSrcweir oslSocketAddr pSenderAddr,
2348cdf0e10cSrcweir void* pBuffer,
2349cdf0e10cSrcweir sal_uInt32 BufferSize,
2350cdf0e10cSrcweir oslSocketMsgFlag Flag)
2351cdf0e10cSrcweir {
2352cdf0e10cSrcweir int nRead;
2353cdf0e10cSrcweir struct sockaddr *pSystemSockAddr = 0;
2354cdf0e10cSrcweir int AddrLen = 0;
2355cdf0e10cSrcweir if( pSenderAddr )
2356cdf0e10cSrcweir {
2357cdf0e10cSrcweir AddrLen = sizeof( struct sockaddr );
2358cdf0e10cSrcweir pSystemSockAddr = &(pSenderAddr->m_sockaddr);
2359cdf0e10cSrcweir }
2360cdf0e10cSrcweir
2361cdf0e10cSrcweir OSL_ASSERT(pSocket);
2362cdf0e10cSrcweir if ( pSocket == 0 )
2363cdf0e10cSrcweir {
2364cdf0e10cSrcweir OSL_TRACE("osl_receiveFromSocket : Invalid socket");
2365cdf0e10cSrcweir return -1;
2366cdf0e10cSrcweir }
2367cdf0e10cSrcweir
2368cdf0e10cSrcweir pSocket->m_nLastError=0;
2369cdf0e10cSrcweir
2370cdf0e10cSrcweir nRead = recvfrom(pSocket->m_Socket,
2371cdf0e10cSrcweir (sal_Char*)pBuffer,
2372cdf0e10cSrcweir BufferSize,
2373cdf0e10cSrcweir MSG_FLAG_TO_NATIVE(Flag),
2374cdf0e10cSrcweir pSystemSockAddr,
2375cdf0e10cSrcweir PTR_SIZE_T(AddrLen));
2376cdf0e10cSrcweir
2377cdf0e10cSrcweir if ( nRead < 0 )
2378cdf0e10cSrcweir {
2379cdf0e10cSrcweir pSocket->m_nLastError=errno;
2380cdf0e10cSrcweir OSL_TRACE("osl_receiveFromSocket failed : %i '%s'",nRead,strerror(errno));
2381cdf0e10cSrcweir }
2382cdf0e10cSrcweir else if ( nRead == 0 )
2383cdf0e10cSrcweir {
2384cdf0e10cSrcweir OSL_TRACE("osl_receiveSocket failed : %i '%s'",nRead,"EOL");
2385cdf0e10cSrcweir }
2386cdf0e10cSrcweir
2387cdf0e10cSrcweir return nRead;
2388cdf0e10cSrcweir }
2389cdf0e10cSrcweir
2390cdf0e10cSrcweir
2391cdf0e10cSrcweir /*****************************************************************************/
2392cdf0e10cSrcweir /* osl_sendSocket */
2393cdf0e10cSrcweir /*****************************************************************************/
osl_sendSocket(oslSocket pSocket,const void * pBuffer,sal_uInt32 BytesToSend,oslSocketMsgFlag Flag)2394cdf0e10cSrcweir sal_Int32 SAL_CALL osl_sendSocket(oslSocket pSocket,
2395cdf0e10cSrcweir const void* pBuffer,
2396cdf0e10cSrcweir sal_uInt32 BytesToSend,
2397cdf0e10cSrcweir oslSocketMsgFlag Flag)
2398cdf0e10cSrcweir {
2399cdf0e10cSrcweir int nWritten;
2400cdf0e10cSrcweir
2401cdf0e10cSrcweir OSL_ASSERT(pSocket);
2402cdf0e10cSrcweir if ( pSocket == 0 )
2403cdf0e10cSrcweir {
2404cdf0e10cSrcweir OSL_TRACE("osl_sendSocket : Invalid socket");
2405cdf0e10cSrcweir return -1;
2406cdf0e10cSrcweir }
2407cdf0e10cSrcweir
2408cdf0e10cSrcweir pSocket->m_nLastError=0;
2409cdf0e10cSrcweir
2410cdf0e10cSrcweir do
2411cdf0e10cSrcweir {
2412cdf0e10cSrcweir nWritten = send(pSocket->m_Socket,
2413cdf0e10cSrcweir (sal_Char*)pBuffer,
2414cdf0e10cSrcweir BytesToSend,
2415cdf0e10cSrcweir MSG_FLAG_TO_NATIVE(Flag));
2416cdf0e10cSrcweir } while ( nWritten < 0 && errno == EINTR );
2417cdf0e10cSrcweir
2418cdf0e10cSrcweir
2419cdf0e10cSrcweir if ( nWritten < 0 )
2420cdf0e10cSrcweir {
2421cdf0e10cSrcweir pSocket->m_nLastError=errno;
2422cdf0e10cSrcweir OSL_TRACE("osl_sendSocket failed : %i '%s'",nWritten,strerror(errno));
2423cdf0e10cSrcweir }
2424cdf0e10cSrcweir else if ( nWritten == 0 )
2425cdf0e10cSrcweir {
2426cdf0e10cSrcweir OSL_TRACE("osl_sendSocket failed : %i '%s'",nWritten,"EOL");
2427cdf0e10cSrcweir }
2428cdf0e10cSrcweir
2429cdf0e10cSrcweir return nWritten;
2430cdf0e10cSrcweir }
2431cdf0e10cSrcweir
2432cdf0e10cSrcweir /*****************************************************************************/
2433cdf0e10cSrcweir /* osl_sendToSocket */
2434cdf0e10cSrcweir /*****************************************************************************/
osl_sendToSocket(oslSocket pSocket,oslSocketAddr ReceiverAddr,const void * pBuffer,sal_uInt32 BytesToSend,oslSocketMsgFlag Flag)2435cdf0e10cSrcweir sal_Int32 SAL_CALL osl_sendToSocket(oslSocket pSocket,
2436cdf0e10cSrcweir oslSocketAddr ReceiverAddr,
2437cdf0e10cSrcweir const void* pBuffer,
2438cdf0e10cSrcweir sal_uInt32 BytesToSend,
2439cdf0e10cSrcweir oslSocketMsgFlag Flag)
2440cdf0e10cSrcweir {
2441cdf0e10cSrcweir int nWritten;
2442cdf0e10cSrcweir
2443cdf0e10cSrcweir struct sockaddr *pSystemSockAddr = 0;
2444cdf0e10cSrcweir int AddrLen = 0;
2445cdf0e10cSrcweir if( ReceiverAddr )
2446cdf0e10cSrcweir {
2447cdf0e10cSrcweir pSystemSockAddr = &(ReceiverAddr->m_sockaddr);
2448cdf0e10cSrcweir AddrLen = sizeof( struct sockaddr );
2449cdf0e10cSrcweir }
2450cdf0e10cSrcweir
2451cdf0e10cSrcweir OSL_ASSERT(pSocket);
2452cdf0e10cSrcweir if ( pSocket == 0 )
2453cdf0e10cSrcweir {
2454cdf0e10cSrcweir OSL_TRACE("osl_sendToSocket : Invalid socket");
2455cdf0e10cSrcweir return -1;
2456cdf0e10cSrcweir }
2457cdf0e10cSrcweir
2458cdf0e10cSrcweir pSocket->m_nLastError=0;
2459cdf0e10cSrcweir
2460cdf0e10cSrcweir /* ReceiverAddr might be 0 when used on a connected socket. */
2461cdf0e10cSrcweir /* Then sendto should behave like send. */
2462cdf0e10cSrcweir
2463cdf0e10cSrcweir nWritten = sendto(pSocket->m_Socket,
2464cdf0e10cSrcweir (sal_Char*)pBuffer,
2465cdf0e10cSrcweir BytesToSend,
2466cdf0e10cSrcweir MSG_FLAG_TO_NATIVE(Flag),
2467cdf0e10cSrcweir pSystemSockAddr,
2468cdf0e10cSrcweir AddrLen);
2469cdf0e10cSrcweir
2470cdf0e10cSrcweir if ( nWritten < 0 )
2471cdf0e10cSrcweir {
2472cdf0e10cSrcweir pSocket->m_nLastError=errno;
2473cdf0e10cSrcweir OSL_TRACE("osl_sendToSocket failed : %i '%s'",nWritten,strerror(errno));
2474cdf0e10cSrcweir }
2475cdf0e10cSrcweir else if ( nWritten == 0 )
2476cdf0e10cSrcweir {
2477cdf0e10cSrcweir OSL_TRACE("osl_sendToSocket failed : %i '%s'",nWritten,"EOL");
2478cdf0e10cSrcweir }
2479cdf0e10cSrcweir
2480cdf0e10cSrcweir return nWritten;
2481cdf0e10cSrcweir }
2482cdf0e10cSrcweir
2483cdf0e10cSrcweir /*****************************************************************************/
2484cdf0e10cSrcweir /* osl_readSocket */
2485cdf0e10cSrcweir /*****************************************************************************/
osl_readSocket(oslSocket pSocket,void * pBuffer,sal_Int32 n)2486cdf0e10cSrcweir sal_Int32 SAL_CALL osl_readSocket (
2487cdf0e10cSrcweir oslSocket pSocket, void *pBuffer, sal_Int32 n )
2488cdf0e10cSrcweir {
2489cdf0e10cSrcweir sal_uInt8 * Ptr = (sal_uInt8 *)pBuffer;
2490cdf0e10cSrcweir sal_uInt32 BytesRead= 0;
2491cdf0e10cSrcweir sal_uInt32 BytesToRead= n;
2492cdf0e10cSrcweir
2493cdf0e10cSrcweir OSL_ASSERT( pSocket);
2494cdf0e10cSrcweir
2495cdf0e10cSrcweir /* loop until all desired bytes were read or an error occured */
2496cdf0e10cSrcweir while (BytesToRead > 0)
2497cdf0e10cSrcweir {
2498cdf0e10cSrcweir sal_Int32 RetVal;
2499cdf0e10cSrcweir RetVal= osl_receiveSocket(pSocket,
2500cdf0e10cSrcweir Ptr,
2501cdf0e10cSrcweir BytesToRead,
2502cdf0e10cSrcweir osl_Socket_MsgNormal);
2503cdf0e10cSrcweir
2504cdf0e10cSrcweir /* error occured? */
2505cdf0e10cSrcweir if(RetVal <= 0)
2506cdf0e10cSrcweir {
2507cdf0e10cSrcweir break;
2508cdf0e10cSrcweir }
2509cdf0e10cSrcweir
2510cdf0e10cSrcweir BytesToRead -= RetVal;
2511cdf0e10cSrcweir BytesRead += RetVal;
2512cdf0e10cSrcweir Ptr += RetVal;
2513cdf0e10cSrcweir }
2514cdf0e10cSrcweir
2515cdf0e10cSrcweir return BytesRead;
2516cdf0e10cSrcweir }
2517cdf0e10cSrcweir
2518cdf0e10cSrcweir /*****************************************************************************/
2519cdf0e10cSrcweir /* osl_writeSocket */
2520cdf0e10cSrcweir /*****************************************************************************/
osl_writeSocket(oslSocket pSocket,const void * pBuffer,sal_Int32 n)2521cdf0e10cSrcweir sal_Int32 SAL_CALL osl_writeSocket(
2522cdf0e10cSrcweir oslSocket pSocket, const void *pBuffer, sal_Int32 n )
2523cdf0e10cSrcweir {
2524cdf0e10cSrcweir /* loop until all desired bytes were send or an error occured */
2525cdf0e10cSrcweir sal_uInt32 BytesSend= 0;
2526cdf0e10cSrcweir sal_uInt32 BytesToSend= n;
2527cdf0e10cSrcweir sal_uInt8 *Ptr = ( sal_uInt8 * )pBuffer;
2528cdf0e10cSrcweir
2529cdf0e10cSrcweir OSL_ASSERT( pSocket );
2530cdf0e10cSrcweir
2531cdf0e10cSrcweir while (BytesToSend > 0)
2532cdf0e10cSrcweir {
2533cdf0e10cSrcweir sal_Int32 RetVal;
2534cdf0e10cSrcweir
2535cdf0e10cSrcweir RetVal= osl_sendSocket( pSocket,Ptr,BytesToSend,osl_Socket_MsgNormal);
2536cdf0e10cSrcweir
2537cdf0e10cSrcweir /* error occured? */
2538cdf0e10cSrcweir if(RetVal <= 0)
2539cdf0e10cSrcweir {
2540cdf0e10cSrcweir break;
2541cdf0e10cSrcweir }
2542cdf0e10cSrcweir
2543cdf0e10cSrcweir BytesToSend -= RetVal;
2544cdf0e10cSrcweir BytesSend += RetVal;
2545cdf0e10cSrcweir Ptr += RetVal;
2546cdf0e10cSrcweir
2547cdf0e10cSrcweir }
2548cdf0e10cSrcweir return BytesSend;
2549cdf0e10cSrcweir }
2550cdf0e10cSrcweir
2551cdf0e10cSrcweir /*****************************************************************************/
2552cdf0e10cSrcweir /* __osl_socket_poll */
2553cdf0e10cSrcweir /*****************************************************************************/
2554cdf0e10cSrcweir
2555cdf0e10cSrcweir #ifdef HAVE_POLL_H /* poll() */
2556cdf0e10cSrcweir
__osl_socket_poll(oslSocket pSocket,const TimeValue * pTimeout,short nEvent)2557cdf0e10cSrcweir sal_Bool __osl_socket_poll (
2558cdf0e10cSrcweir oslSocket pSocket,
2559cdf0e10cSrcweir const TimeValue* pTimeout,
2560cdf0e10cSrcweir short nEvent)
2561cdf0e10cSrcweir {
2562cdf0e10cSrcweir struct pollfd fds;
2563cdf0e10cSrcweir int timeout;
2564cdf0e10cSrcweir int result;
2565cdf0e10cSrcweir
2566cdf0e10cSrcweir OSL_ASSERT(pSocket);
2567cdf0e10cSrcweir pSocket->m_nLastError = 0;
2568cdf0e10cSrcweir
2569cdf0e10cSrcweir fds.fd = pSocket->m_Socket;
2570cdf0e10cSrcweir fds.events = nEvent;
2571cdf0e10cSrcweir fds.revents = 0;
2572cdf0e10cSrcweir
2573cdf0e10cSrcweir timeout = -1;
2574cdf0e10cSrcweir if (pTimeout)
2575cdf0e10cSrcweir {
2576cdf0e10cSrcweir /* Convert to [ms] */
2577cdf0e10cSrcweir timeout = pTimeout->Seconds * 1000;
2578cdf0e10cSrcweir timeout += pTimeout->Nanosec / (1000 * 1000);
2579cdf0e10cSrcweir }
2580cdf0e10cSrcweir
2581cdf0e10cSrcweir result = poll (&fds, 1, timeout);
2582cdf0e10cSrcweir if (result < 0)
2583cdf0e10cSrcweir {
2584cdf0e10cSrcweir pSocket->m_nLastError = errno;
2585cdf0e10cSrcweir OSL_TRACE("__osl_socket_poll(): poll error: %d (%s)",
2586cdf0e10cSrcweir errno, strerror(errno));
2587cdf0e10cSrcweir return sal_False;
2588cdf0e10cSrcweir }
2589cdf0e10cSrcweir if (result == 0)
2590cdf0e10cSrcweir {
2591cdf0e10cSrcweir /* Timeout */
2592cdf0e10cSrcweir return sal_False;
2593cdf0e10cSrcweir }
2594cdf0e10cSrcweir
2595cdf0e10cSrcweir return ((fds.revents & nEvent) == nEvent);
2596cdf0e10cSrcweir }
2597cdf0e10cSrcweir
2598cdf0e10cSrcweir #else /* select() */
2599cdf0e10cSrcweir
__osl_socket_poll(oslSocket pSocket,const TimeValue * pTimeout,short nEvent)2600cdf0e10cSrcweir sal_Bool __osl_socket_poll (
2601cdf0e10cSrcweir oslSocket pSocket,
2602cdf0e10cSrcweir const TimeValue* pTimeout,
2603cdf0e10cSrcweir short nEvent)
2604cdf0e10cSrcweir {
2605cdf0e10cSrcweir fd_set fds;
2606cdf0e10cSrcweir struct timeval tv;
2607cdf0e10cSrcweir int result;
2608cdf0e10cSrcweir
2609cdf0e10cSrcweir OSL_ASSERT(pSocket);
2610cdf0e10cSrcweir pSocket->m_nLastError = 0;
2611cdf0e10cSrcweir
2612cdf0e10cSrcweir FD_ZERO(&fds);
2613cdf0e10cSrcweir FD_SET(pSocket->m_Socket, &fds);
2614cdf0e10cSrcweir
2615cdf0e10cSrcweir if (pTimeout)
2616cdf0e10cSrcweir {
2617cdf0e10cSrcweir /* Convert to 'timeval' */
2618cdf0e10cSrcweir tv.tv_sec = pTimeout->Seconds;
2619cdf0e10cSrcweir tv.tv_usec = pTimeout->Nanosec / 1000;
2620cdf0e10cSrcweir }
2621cdf0e10cSrcweir
2622cdf0e10cSrcweir result = select (
2623cdf0e10cSrcweir pSocket->m_Socket + 1,
2624cdf0e10cSrcweir (nEvent == POLLIN ) ? PTR_FD_SET(fds) : NULL,
2625cdf0e10cSrcweir (nEvent == POLLOUT) ? PTR_FD_SET(fds) : NULL,
2626cdf0e10cSrcweir (nEvent == POLLPRI) ? PTR_FD_SET(fds) : NULL,
2627cdf0e10cSrcweir (pTimeout) ? &tv : NULL);
2628cdf0e10cSrcweir
2629cdf0e10cSrcweir if (result < 0)
2630cdf0e10cSrcweir {
2631cdf0e10cSrcweir pSocket->m_nLastError = errno;
2632cdf0e10cSrcweir OSL_TRACE("__osl_socket_poll(): select error: %d (%s)",
2633cdf0e10cSrcweir errno, strerror(errno));
2634cdf0e10cSrcweir return sal_False;
2635cdf0e10cSrcweir }
2636cdf0e10cSrcweir if (result == 0)
2637cdf0e10cSrcweir {
2638cdf0e10cSrcweir /* Timeout */
2639cdf0e10cSrcweir return sal_False;
2640cdf0e10cSrcweir }
2641cdf0e10cSrcweir
2642cdf0e10cSrcweir return (FD_ISSET(pSocket->m_Socket, &fds) ? sal_True : sal_False);
2643cdf0e10cSrcweir }
2644cdf0e10cSrcweir
2645cdf0e10cSrcweir #endif /* HAVE_POLL_H */
2646cdf0e10cSrcweir
2647cdf0e10cSrcweir /*****************************************************************************/
2648cdf0e10cSrcweir /* osl_isReceiveReady */
2649cdf0e10cSrcweir /*****************************************************************************/
osl_isReceiveReady(oslSocket pSocket,const TimeValue * pTimeout)2650cdf0e10cSrcweir sal_Bool SAL_CALL osl_isReceiveReady (
2651cdf0e10cSrcweir oslSocket pSocket, const TimeValue* pTimeout)
2652cdf0e10cSrcweir {
2653cdf0e10cSrcweir OSL_ASSERT(pSocket);
2654cdf0e10cSrcweir if (pSocket == NULL)
2655cdf0e10cSrcweir {
2656cdf0e10cSrcweir /* ENOTSOCK */
2657cdf0e10cSrcweir return sal_False;
2658cdf0e10cSrcweir }
2659cdf0e10cSrcweir
2660cdf0e10cSrcweir return __osl_socket_poll (pSocket, pTimeout, POLLIN);
2661cdf0e10cSrcweir }
2662cdf0e10cSrcweir
2663cdf0e10cSrcweir /*****************************************************************************/
2664cdf0e10cSrcweir /* osl_isSendReady */
2665cdf0e10cSrcweir /*****************************************************************************/
osl_isSendReady(oslSocket pSocket,const TimeValue * pTimeout)2666cdf0e10cSrcweir sal_Bool SAL_CALL osl_isSendReady (
2667cdf0e10cSrcweir oslSocket pSocket, const TimeValue* pTimeout)
2668cdf0e10cSrcweir {
2669cdf0e10cSrcweir OSL_ASSERT(pSocket);
2670cdf0e10cSrcweir if (pSocket == NULL)
2671cdf0e10cSrcweir {
2672cdf0e10cSrcweir /* ENOTSOCK */
2673cdf0e10cSrcweir return sal_False;
2674cdf0e10cSrcweir }
2675cdf0e10cSrcweir
2676cdf0e10cSrcweir return __osl_socket_poll (pSocket, pTimeout, POLLOUT);
2677cdf0e10cSrcweir }
2678cdf0e10cSrcweir
2679cdf0e10cSrcweir /*****************************************************************************/
2680cdf0e10cSrcweir /* osl_isExceptionPending */
2681cdf0e10cSrcweir /*****************************************************************************/
osl_isExceptionPending(oslSocket pSocket,const TimeValue * pTimeout)2682cdf0e10cSrcweir sal_Bool SAL_CALL osl_isExceptionPending (
2683cdf0e10cSrcweir oslSocket pSocket, const TimeValue* pTimeout)
2684cdf0e10cSrcweir {
2685cdf0e10cSrcweir OSL_ASSERT(pSocket);
2686cdf0e10cSrcweir if (pSocket == NULL)
2687cdf0e10cSrcweir {
2688cdf0e10cSrcweir /* ENOTSOCK */
2689cdf0e10cSrcweir return sal_False;
2690cdf0e10cSrcweir }
2691cdf0e10cSrcweir
2692cdf0e10cSrcweir return __osl_socket_poll (pSocket, pTimeout, POLLPRI);
2693cdf0e10cSrcweir }
2694cdf0e10cSrcweir
2695cdf0e10cSrcweir /*****************************************************************************/
2696cdf0e10cSrcweir /* osl_shutdownSocket */
2697cdf0e10cSrcweir /*****************************************************************************/
osl_shutdownSocket(oslSocket pSocket,oslSocketDirection Direction)2698cdf0e10cSrcweir sal_Bool SAL_CALL osl_shutdownSocket(oslSocket pSocket,
2699cdf0e10cSrcweir oslSocketDirection Direction)
2700cdf0e10cSrcweir {
2701cdf0e10cSrcweir int nRet;
2702cdf0e10cSrcweir
2703cdf0e10cSrcweir OSL_ASSERT(pSocket);
2704cdf0e10cSrcweir if ( pSocket == 0 )
2705cdf0e10cSrcweir {
2706cdf0e10cSrcweir return sal_False;
2707cdf0e10cSrcweir }
2708cdf0e10cSrcweir
2709cdf0e10cSrcweir pSocket->m_nLastError=0;
2710cdf0e10cSrcweir
2711cdf0e10cSrcweir nRet=shutdown(pSocket->m_Socket, DIRECTION_TO_NATIVE(Direction));
2712cdf0e10cSrcweir if (nRet != 0 )
2713cdf0e10cSrcweir {
2714cdf0e10cSrcweir pSocket->m_nLastError=errno;
2715cdf0e10cSrcweir OSL_TRACE("shutdown error '%s'\n",strerror(errno));
2716cdf0e10cSrcweir }
2717cdf0e10cSrcweir return (nRet==0);
2718cdf0e10cSrcweir }
2719cdf0e10cSrcweir
2720cdf0e10cSrcweir
2721cdf0e10cSrcweir /*****************************************************************************/
2722cdf0e10cSrcweir /* osl_getSocketOption */
2723cdf0e10cSrcweir /*****************************************************************************/
osl_getSocketOption(oslSocket pSocket,oslSocketOptionLevel Level,oslSocketOption Option,void * pBuffer,sal_uInt32 BufferLen)2724cdf0e10cSrcweir sal_Int32 SAL_CALL osl_getSocketOption(oslSocket pSocket,
2725cdf0e10cSrcweir oslSocketOptionLevel Level,
2726cdf0e10cSrcweir oslSocketOption Option,
2727cdf0e10cSrcweir void* pBuffer,
2728cdf0e10cSrcweir sal_uInt32 BufferLen)
2729cdf0e10cSrcweir {
2730cdf0e10cSrcweir OSL_ASSERT(pSocket);
2731cdf0e10cSrcweir if ( pSocket == 0 )
2732cdf0e10cSrcweir {
2733cdf0e10cSrcweir return -1;
2734cdf0e10cSrcweir }
2735cdf0e10cSrcweir
2736cdf0e10cSrcweir pSocket->m_nLastError=0;
2737cdf0e10cSrcweir
2738cdf0e10cSrcweir if(getsockopt(pSocket->m_Socket,
2739cdf0e10cSrcweir OPTION_LEVEL_TO_NATIVE(Level),
2740cdf0e10cSrcweir OPTION_TO_NATIVE(Option),
2741cdf0e10cSrcweir (sal_Char*)pBuffer,
2742cdf0e10cSrcweir (int*)PTR_SIZE_T(BufferLen)) == -1)
2743cdf0e10cSrcweir {
2744cdf0e10cSrcweir pSocket->m_nLastError=errno;
2745cdf0e10cSrcweir return -1;
2746cdf0e10cSrcweir }
2747cdf0e10cSrcweir
2748cdf0e10cSrcweir return BufferLen;
2749cdf0e10cSrcweir }
2750cdf0e10cSrcweir
2751cdf0e10cSrcweir /*****************************************************************************/
2752cdf0e10cSrcweir /* osl_setSocketOption */
2753cdf0e10cSrcweir /*****************************************************************************/
osl_setSocketOption(oslSocket pSocket,oslSocketOptionLevel Level,oslSocketOption Option,void * pBuffer,sal_uInt32 BufferLen)2754cdf0e10cSrcweir sal_Bool SAL_CALL osl_setSocketOption(oslSocket pSocket,
2755cdf0e10cSrcweir oslSocketOptionLevel Level,
2756cdf0e10cSrcweir oslSocketOption Option,
2757cdf0e10cSrcweir void* pBuffer,
2758cdf0e10cSrcweir sal_uInt32 BufferLen)
2759cdf0e10cSrcweir {
2760cdf0e10cSrcweir int nRet;
2761cdf0e10cSrcweir
2762cdf0e10cSrcweir OSL_ASSERT(pSocket);
2763cdf0e10cSrcweir if ( pSocket == 0 )
2764cdf0e10cSrcweir {
2765cdf0e10cSrcweir return sal_False;
2766cdf0e10cSrcweir }
2767cdf0e10cSrcweir
2768cdf0e10cSrcweir pSocket->m_nLastError=0;
2769cdf0e10cSrcweir
2770cdf0e10cSrcweir nRet = setsockopt(pSocket->m_Socket,
2771cdf0e10cSrcweir OPTION_LEVEL_TO_NATIVE(Level),
2772cdf0e10cSrcweir OPTION_TO_NATIVE(Option),
2773cdf0e10cSrcweir (sal_Char*)pBuffer,
2774cdf0e10cSrcweir BufferLen);
2775cdf0e10cSrcweir
2776cdf0e10cSrcweir if ( nRet < 0 )
2777cdf0e10cSrcweir {
2778cdf0e10cSrcweir pSocket->m_nLastError=errno;
2779cdf0e10cSrcweir return sal_False;
2780cdf0e10cSrcweir }
2781cdf0e10cSrcweir
2782cdf0e10cSrcweir return sal_True;
2783cdf0e10cSrcweir }
2784cdf0e10cSrcweir
2785cdf0e10cSrcweir /*****************************************************************************/
2786cdf0e10cSrcweir /* osl_enableNonBlockingMode */
2787cdf0e10cSrcweir /*****************************************************************************/
osl_enableNonBlockingMode(oslSocket pSocket,sal_Bool On)2788cdf0e10cSrcweir sal_Bool SAL_CALL osl_enableNonBlockingMode(oslSocket pSocket,
2789cdf0e10cSrcweir sal_Bool On)
2790cdf0e10cSrcweir {
2791cdf0e10cSrcweir int flags;
2792cdf0e10cSrcweir int nRet;
2793cdf0e10cSrcweir
2794cdf0e10cSrcweir OSL_ASSERT(pSocket);
2795cdf0e10cSrcweir if ( pSocket == 0 )
2796cdf0e10cSrcweir {
2797cdf0e10cSrcweir return sal_False;
2798cdf0e10cSrcweir }
2799cdf0e10cSrcweir
2800cdf0e10cSrcweir pSocket->m_nLastError=0;
2801cdf0e10cSrcweir
2802cdf0e10cSrcweir flags = fcntl(pSocket->m_Socket, F_GETFL, 0);
2803cdf0e10cSrcweir
2804cdf0e10cSrcweir if (On)
2805cdf0e10cSrcweir flags |= O_NONBLOCK;
2806cdf0e10cSrcweir else
2807cdf0e10cSrcweir flags &= ~(O_NONBLOCK);
2808cdf0e10cSrcweir
2809cdf0e10cSrcweir nRet = fcntl(pSocket->m_Socket, F_SETFL, flags);
2810cdf0e10cSrcweir
2811cdf0e10cSrcweir if ( nRet < 0 )
2812cdf0e10cSrcweir {
2813cdf0e10cSrcweir pSocket->m_nLastError=errno;
2814cdf0e10cSrcweir return sal_False;
2815cdf0e10cSrcweir }
2816cdf0e10cSrcweir
2817cdf0e10cSrcweir return sal_True;
2818cdf0e10cSrcweir }
2819cdf0e10cSrcweir
2820cdf0e10cSrcweir /*****************************************************************************/
2821cdf0e10cSrcweir /* osl_isNonBlockingMode */
2822cdf0e10cSrcweir /*****************************************************************************/
osl_isNonBlockingMode(oslSocket pSocket)2823cdf0e10cSrcweir sal_Bool SAL_CALL osl_isNonBlockingMode(oslSocket pSocket)
2824cdf0e10cSrcweir {
2825cdf0e10cSrcweir int flags;
2826cdf0e10cSrcweir
2827cdf0e10cSrcweir OSL_ASSERT(pSocket);
2828cdf0e10cSrcweir if ( pSocket == 0 )
2829cdf0e10cSrcweir {
2830cdf0e10cSrcweir return sal_False;
2831cdf0e10cSrcweir }
2832cdf0e10cSrcweir
2833cdf0e10cSrcweir pSocket->m_nLastError=0;
2834cdf0e10cSrcweir
2835cdf0e10cSrcweir flags = fcntl(pSocket->m_Socket, F_GETFL, 0);
2836cdf0e10cSrcweir
2837cdf0e10cSrcweir if (flags == -1 || !(flags & O_NONBLOCK))
2838cdf0e10cSrcweir return sal_False;
2839cdf0e10cSrcweir else
2840cdf0e10cSrcweir return sal_True;
2841cdf0e10cSrcweir }
2842cdf0e10cSrcweir
2843cdf0e10cSrcweir /*****************************************************************************/
2844cdf0e10cSrcweir /* osl_getSocketType */
2845cdf0e10cSrcweir /*****************************************************************************/
osl_getSocketType(oslSocket pSocket)2846cdf0e10cSrcweir oslSocketType SAL_CALL osl_getSocketType(oslSocket pSocket)
2847cdf0e10cSrcweir {
2848cdf0e10cSrcweir int Type=0;
2849cdf0e10cSrcweir sal_uInt32 TypeSize= sizeof(Type);
2850cdf0e10cSrcweir
2851cdf0e10cSrcweir OSL_ASSERT(pSocket);
2852cdf0e10cSrcweir if ( pSocket == 0 )
2853cdf0e10cSrcweir {
2854cdf0e10cSrcweir return osl_Socket_TypeInvalid;
2855cdf0e10cSrcweir }
2856cdf0e10cSrcweir
2857cdf0e10cSrcweir pSocket->m_nLastError=0;
2858cdf0e10cSrcweir
2859cdf0e10cSrcweir if(getsockopt(pSocket->m_Socket,
2860cdf0e10cSrcweir OPTION_LEVEL_TO_NATIVE(osl_Socket_LevelSocket),
2861cdf0e10cSrcweir OPTION_TO_NATIVE(osl_Socket_OptionType),
2862cdf0e10cSrcweir (sal_Char*)&Type,
2863cdf0e10cSrcweir (int*)PTR_SIZE_T(TypeSize)) == -1)
2864cdf0e10cSrcweir {
2865cdf0e10cSrcweir /* error */
2866cdf0e10cSrcweir pSocket->m_nLastError=errno;
2867cdf0e10cSrcweir return osl_Socket_TypeInvalid;
2868cdf0e10cSrcweir }
2869cdf0e10cSrcweir
2870cdf0e10cSrcweir return TYPE_FROM_NATIVE(Type);
2871cdf0e10cSrcweir
2872cdf0e10cSrcweir }
2873cdf0e10cSrcweir
2874cdf0e10cSrcweir /*****************************************************************************/
2875cdf0e10cSrcweir /* osl_getLastSocketErrorDescription */
2876cdf0e10cSrcweir /*****************************************************************************/
osl_getLastSocketErrorDescription(oslSocket Socket,rtl_uString ** ustrError)2877cdf0e10cSrcweir void SAL_CALL osl_getLastSocketErrorDescription(oslSocket Socket, rtl_uString **ustrError)
2878cdf0e10cSrcweir {
2879cdf0e10cSrcweir sal_Char pszError[1024];
2880cdf0e10cSrcweir
2881cdf0e10cSrcweir pszError[0] = '\0';
2882cdf0e10cSrcweir
2883cdf0e10cSrcweir osl_psz_getLastSocketErrorDescription(Socket,pszError,sizeof(pszError));
2884cdf0e10cSrcweir
2885cdf0e10cSrcweir rtl_uString_newFromAscii(ustrError,pszError);
2886cdf0e10cSrcweir
2887cdf0e10cSrcweir return;
2888cdf0e10cSrcweir }
2889cdf0e10cSrcweir
2890cdf0e10cSrcweir
osl_psz_getLastSocketErrorDescription(oslSocket pSocket,sal_Char * pBuffer,sal_uInt32 BufferSize)2891cdf0e10cSrcweir void SAL_CALL osl_psz_getLastSocketErrorDescription(oslSocket pSocket, sal_Char* pBuffer, sal_uInt32 BufferSize)
2892cdf0e10cSrcweir {
2893cdf0e10cSrcweir /* make shure pBuffer will be a zero-terminated string even when strncpy has to cut */
2894cdf0e10cSrcweir pBuffer[BufferSize-1]= '\0';
2895cdf0e10cSrcweir
2896cdf0e10cSrcweir if ( pSocket == 0 )
2897cdf0e10cSrcweir {
2898cdf0e10cSrcweir strncpy(pBuffer, strerror(EINVAL), BufferSize-1);
2899cdf0e10cSrcweir return;
2900cdf0e10cSrcweir }
2901cdf0e10cSrcweir
2902cdf0e10cSrcweir strncpy(pBuffer, strerror(pSocket->m_nLastError), BufferSize-1);
2903cdf0e10cSrcweir return;
2904cdf0e10cSrcweir }
2905cdf0e10cSrcweir
2906cdf0e10cSrcweir /*****************************************************************************/
2907cdf0e10cSrcweir /* osl_getLastSocketError */
2908cdf0e10cSrcweir /*****************************************************************************/
osl_getLastSocketError(oslSocket pSocket)2909cdf0e10cSrcweir oslSocketError SAL_CALL osl_getLastSocketError(oslSocket pSocket)
2910cdf0e10cSrcweir {
2911cdf0e10cSrcweir if ( pSocket == 0 )
2912cdf0e10cSrcweir {
2913cdf0e10cSrcweir return ERROR_FROM_NATIVE(EINVAL);
2914cdf0e10cSrcweir }
2915cdf0e10cSrcweir
2916cdf0e10cSrcweir return ERROR_FROM_NATIVE(pSocket->m_nLastError);
2917cdf0e10cSrcweir }
2918cdf0e10cSrcweir
2919cdf0e10cSrcweir /*****************************************************************************/
2920cdf0e10cSrcweir /* SocketSet */
2921cdf0e10cSrcweir /*****************************************************************************/
2922cdf0e10cSrcweir typedef struct _TSocketSetImpl
2923cdf0e10cSrcweir {
2924cdf0e10cSrcweir int m_MaxHandle; /* for select(), the largest descriptor in the set */
2925cdf0e10cSrcweir fd_set m_Set; /* the set of descriptors */
2926cdf0e10cSrcweir
2927cdf0e10cSrcweir } TSocketSetImpl;
2928cdf0e10cSrcweir
2929cdf0e10cSrcweir /*****************************************************************************/
2930cdf0e10cSrcweir /* osl_createSocketSet */
2931cdf0e10cSrcweir /*****************************************************************************/
osl_createSocketSet()2932cdf0e10cSrcweir oslSocketSet SAL_CALL osl_createSocketSet()
2933cdf0e10cSrcweir {
2934cdf0e10cSrcweir TSocketSetImpl* pSet;
2935cdf0e10cSrcweir
2936cdf0e10cSrcweir pSet= (TSocketSetImpl*)malloc(sizeof(TSocketSetImpl));
2937cdf0e10cSrcweir
2938cdf0e10cSrcweir OSL_ASSERT(pSet);
2939cdf0e10cSrcweir
2940cdf0e10cSrcweir if(pSet)
2941cdf0e10cSrcweir {
2942cdf0e10cSrcweir pSet->m_MaxHandle= 0;
2943cdf0e10cSrcweir FD_ZERO(&pSet->m_Set);
2944cdf0e10cSrcweir }
2945cdf0e10cSrcweir
2946cdf0e10cSrcweir return (oslSocketSet)pSet;
2947cdf0e10cSrcweir }
2948cdf0e10cSrcweir
2949cdf0e10cSrcweir /*****************************************************************************/
2950cdf0e10cSrcweir /* osl_destroySocketSet */
2951cdf0e10cSrcweir /*****************************************************************************/
osl_destroySocketSet(oslSocketSet Set)2952cdf0e10cSrcweir void SAL_CALL osl_destroySocketSet(oslSocketSet Set)
2953cdf0e10cSrcweir {
2954cdf0e10cSrcweir if(Set)
2955cdf0e10cSrcweir free(Set);
2956cdf0e10cSrcweir }
2957cdf0e10cSrcweir
2958cdf0e10cSrcweir /*****************************************************************************/
2959cdf0e10cSrcweir /* osl_clearSocketSet */
2960cdf0e10cSrcweir /*****************************************************************************/
osl_clearSocketSet(oslSocketSet Set)2961cdf0e10cSrcweir void SAL_CALL osl_clearSocketSet(oslSocketSet Set)
2962cdf0e10cSrcweir {
2963cdf0e10cSrcweir TSocketSetImpl* pSet;
2964cdf0e10cSrcweir OSL_ASSERT(Set);
2965cdf0e10cSrcweir if ( Set == 0 )
2966cdf0e10cSrcweir {
2967cdf0e10cSrcweir return;
2968cdf0e10cSrcweir }
2969cdf0e10cSrcweir
2970cdf0e10cSrcweir pSet= (TSocketSetImpl*)Set;
2971cdf0e10cSrcweir pSet->m_MaxHandle= 0;
2972cdf0e10cSrcweir
2973cdf0e10cSrcweir FD_ZERO(&pSet->m_Set);
2974cdf0e10cSrcweir }
2975cdf0e10cSrcweir
2976cdf0e10cSrcweir /*****************************************************************************/
2977cdf0e10cSrcweir /* osl_addToSocketSet */
2978cdf0e10cSrcweir /*****************************************************************************/
osl_addToSocketSet(oslSocketSet Set,oslSocket pSocket)2979cdf0e10cSrcweir void SAL_CALL osl_addToSocketSet(oslSocketSet Set, oslSocket pSocket)
2980cdf0e10cSrcweir {
2981cdf0e10cSrcweir TSocketSetImpl* pSet;
2982cdf0e10cSrcweir
2983cdf0e10cSrcweir OSL_ASSERT(Set);
2984cdf0e10cSrcweir OSL_ASSERT(pSocket);
2985cdf0e10cSrcweir
2986cdf0e10cSrcweir if ( Set == 0 || pSocket == 0)
2987cdf0e10cSrcweir {
2988cdf0e10cSrcweir return;
2989cdf0e10cSrcweir }
2990cdf0e10cSrcweir
2991cdf0e10cSrcweir pSet= (TSocketSetImpl*)Set;
2992cdf0e10cSrcweir
2993cdf0e10cSrcweir /* correct max handle */
2994cdf0e10cSrcweir if(pSocket->m_Socket > pSet->m_MaxHandle)
2995cdf0e10cSrcweir pSet->m_MaxHandle= pSocket->m_Socket;
2996cdf0e10cSrcweir FD_SET(pSocket->m_Socket, &pSet->m_Set);
2997cdf0e10cSrcweir
2998cdf0e10cSrcweir }
2999cdf0e10cSrcweir
3000cdf0e10cSrcweir /*****************************************************************************/
3001cdf0e10cSrcweir /* osl_removeFromSocketSet */
3002cdf0e10cSrcweir /*****************************************************************************/
osl_removeFromSocketSet(oslSocketSet Set,oslSocket pSocket)3003cdf0e10cSrcweir void SAL_CALL osl_removeFromSocketSet(oslSocketSet Set, oslSocket pSocket)
3004cdf0e10cSrcweir {
3005cdf0e10cSrcweir TSocketSetImpl* pSet;
3006cdf0e10cSrcweir
3007cdf0e10cSrcweir OSL_ASSERT(Set);
3008cdf0e10cSrcweir OSL_ASSERT(pSocket);
3009cdf0e10cSrcweir
3010cdf0e10cSrcweir if ( Set == 0 || pSocket == 0)
3011cdf0e10cSrcweir {
3012cdf0e10cSrcweir return;
3013cdf0e10cSrcweir }
3014cdf0e10cSrcweir
3015cdf0e10cSrcweir pSet= (TSocketSetImpl*)Set;
3016cdf0e10cSrcweir
3017cdf0e10cSrcweir /* correct max handle */
3018cdf0e10cSrcweir if(pSocket->m_Socket == pSet->m_MaxHandle)
3019cdf0e10cSrcweir {
3020cdf0e10cSrcweir /* not optimal, since the next used descriptor might be */
3021cdf0e10cSrcweir /* much smaller than m_Socket-1, but it will do */
3022cdf0e10cSrcweir pSet->m_MaxHandle--;
3023cdf0e10cSrcweir if(pSet->m_MaxHandle < 0)
3024cdf0e10cSrcweir {
3025cdf0e10cSrcweir pSet->m_MaxHandle= 0; /* avoid underflow */
3026cdf0e10cSrcweir }
3027cdf0e10cSrcweir }
3028cdf0e10cSrcweir
3029cdf0e10cSrcweir FD_CLR(pSocket->m_Socket, &pSet->m_Set);
3030cdf0e10cSrcweir }
3031cdf0e10cSrcweir
3032cdf0e10cSrcweir /*****************************************************************************/
3033cdf0e10cSrcweir /* osl_isInSocketSet */
3034cdf0e10cSrcweir /*****************************************************************************/
osl_isInSocketSet(oslSocketSet Set,oslSocket pSocket)3035cdf0e10cSrcweir sal_Bool SAL_CALL osl_isInSocketSet(oslSocketSet Set, oslSocket pSocket)
3036cdf0e10cSrcweir {
3037cdf0e10cSrcweir TSocketSetImpl* pSet;
3038cdf0e10cSrcweir
3039cdf0e10cSrcweir OSL_ASSERT(Set);
3040cdf0e10cSrcweir OSL_ASSERT(pSocket);
3041cdf0e10cSrcweir if ( Set == 0 || pSocket == 0 )
3042cdf0e10cSrcweir {
3043cdf0e10cSrcweir return sal_False;
3044cdf0e10cSrcweir }
3045cdf0e10cSrcweir
3046cdf0e10cSrcweir pSet= (TSocketSetImpl*)Set;
3047cdf0e10cSrcweir
3048cdf0e10cSrcweir return (FD_ISSET(pSocket->m_Socket, &pSet->m_Set) != 0);
3049cdf0e10cSrcweir }
3050cdf0e10cSrcweir
3051cdf0e10cSrcweir /*****************************************************************************/
3052cdf0e10cSrcweir /* osl_demultiplexSocketEvents */
3053cdf0e10cSrcweir /*****************************************************************************/
osl_demultiplexSocketEvents(oslSocketSet IncomingSet,oslSocketSet OutgoingSet,oslSocketSet OutOfBandSet,const TimeValue * pTimeout)3054cdf0e10cSrcweir sal_Int32 SAL_CALL osl_demultiplexSocketEvents(oslSocketSet IncomingSet,
3055cdf0e10cSrcweir oslSocketSet OutgoingSet,
3056cdf0e10cSrcweir oslSocketSet OutOfBandSet,
3057cdf0e10cSrcweir const TimeValue* pTimeout)
3058cdf0e10cSrcweir {
3059cdf0e10cSrcweir int MaxHandle= 0;
3060cdf0e10cSrcweir struct timeval tv;
3061cdf0e10cSrcweir TSocketSetImpl* pInSet;
3062cdf0e10cSrcweir TSocketSetImpl* pOutSet;
3063cdf0e10cSrcweir TSocketSetImpl* pOOBSet;
3064cdf0e10cSrcweir
3065cdf0e10cSrcweir if (pTimeout)
3066cdf0e10cSrcweir {
3067cdf0e10cSrcweir /* non-blocking call */
3068cdf0e10cSrcweir tv.tv_sec = pTimeout->Seconds;
3069cdf0e10cSrcweir tv.tv_usec = pTimeout->Nanosec / 1000L;
3070cdf0e10cSrcweir }
3071cdf0e10cSrcweir
3072cdf0e10cSrcweir /* map opaque data to impl-types */
3073cdf0e10cSrcweir pInSet= (TSocketSetImpl*)IncomingSet;
3074cdf0e10cSrcweir pOutSet= (TSocketSetImpl*)OutgoingSet;
3075cdf0e10cSrcweir pOOBSet= (TSocketSetImpl*)OutOfBandSet;
3076cdf0e10cSrcweir
3077cdf0e10cSrcweir /* get max handle from all sets */
3078cdf0e10cSrcweir if (pInSet)
3079cdf0e10cSrcweir MaxHandle= pInSet->m_MaxHandle;
3080cdf0e10cSrcweir
3081cdf0e10cSrcweir if (pOutSet && (pOutSet->m_MaxHandle > MaxHandle))
3082cdf0e10cSrcweir MaxHandle= pOutSet->m_MaxHandle;
3083cdf0e10cSrcweir
3084cdf0e10cSrcweir if (pOOBSet && (pOOBSet->m_MaxHandle > MaxHandle))
3085cdf0e10cSrcweir MaxHandle= pOOBSet->m_MaxHandle;
3086cdf0e10cSrcweir
3087cdf0e10cSrcweir return select(MaxHandle+1,
3088cdf0e10cSrcweir pInSet ? PTR_FD_SET(pInSet->m_Set) : 0,
3089cdf0e10cSrcweir pOutSet ? PTR_FD_SET(pOutSet->m_Set) : 0,
3090cdf0e10cSrcweir pOOBSet ? PTR_FD_SET(pOOBSet->m_Set) : 0,
3091cdf0e10cSrcweir pTimeout ? &tv : 0);
3092cdf0e10cSrcweir }
3093cdf0e10cSrcweir
3094