1647f063dSAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
3647f063dSAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4647f063dSAndrew Rist * or more contributor license agreements. See the NOTICE file
5647f063dSAndrew Rist * distributed with this work for additional information
6647f063dSAndrew Rist * regarding copyright ownership. The ASF licenses this file
7647f063dSAndrew Rist * to you under the Apache License, Version 2.0 (the
8647f063dSAndrew Rist * "License"); you may not use this file except in compliance
9647f063dSAndrew Rist * with the License. You may obtain a copy of the License at
10647f063dSAndrew Rist *
11647f063dSAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
12647f063dSAndrew Rist *
13647f063dSAndrew Rist * Unless required by applicable law or agreed to in writing,
14647f063dSAndrew Rist * software distributed under the License is distributed on an
15647f063dSAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16647f063dSAndrew Rist * KIND, either express or implied. See the License for the
17647f063dSAndrew Rist * specific language governing permissions and limitations
18647f063dSAndrew Rist * under the License.
19647f063dSAndrew Rist *
20647f063dSAndrew Rist *************************************************************/
21647f063dSAndrew Rist
22647f063dSAndrew 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
493*0d76dfe8SAndrea Pescetti #if CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT
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 OSL_ASSERT((0 != Addr1) && (0 != Addr2));
605cdf0e10cSrcweir if ((0 != Addr1) || (0 != Addr2))
606cdf0e10cSrcweir {
607cdf0e10cSrcweir struct sockaddr* pAddr1= &(Addr1->m_sockaddr);
608cdf0e10cSrcweir struct sockaddr* pAddr2= &(Addr2->m_sockaddr);
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, pAddr2, 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 #if defined(LINUX) || (defined(FREEBSD) && (__FreeBSD_version >= 601103))
796cdf0e10cSrcweir struct hostent *__result; /* will be the same as result */
797cdf0e10cSrcweir int __error;
798cdf0e10cSrcweir __error = gethostbyname_r (name, result, buffer, buflen,
799cdf0e10cSrcweir &__result, h_errnop);
800cdf0e10cSrcweir return __error ? NULL : __result ;
801cdf0e10cSrcweir #else
802cdf0e10cSrcweir return gethostbyname_r( name, result, buffer, buflen, h_errnop);
803cdf0e10cSrcweir #endif
804cdf0e10cSrcweir }
805cdf0e10cSrcweir
_osl_getDomainName(sal_Char * buffer,sal_Int32 bufsiz)806cdf0e10cSrcweir static sal_Bool _osl_getDomainName (sal_Char *buffer, sal_Int32 bufsiz)
807cdf0e10cSrcweir {
808cdf0e10cSrcweir sal_Bool result;
809cdf0e10cSrcweir int p[2];
810cdf0e10cSrcweir
811cdf0e10cSrcweir result = sal_False;
812cdf0e10cSrcweir if (pipe (p) == 0)
813cdf0e10cSrcweir {
814cdf0e10cSrcweir pid_t pid;
815cdf0e10cSrcweir int nStatus;
816cdf0e10cSrcweir
817cdf0e10cSrcweir pid = fork();
818cdf0e10cSrcweir if (pid == 0)
819cdf0e10cSrcweir {
820cdf0e10cSrcweir char *argv[] =
821cdf0e10cSrcweir {
822cdf0e10cSrcweir "/bin/domainname",
823cdf0e10cSrcweir NULL
824cdf0e10cSrcweir };
825cdf0e10cSrcweir
826cdf0e10cSrcweir close (p[0]);
827cdf0e10cSrcweir dup2 (p[1], 1);
828cdf0e10cSrcweir close (p[1]);
829cdf0e10cSrcweir
830cdf0e10cSrcweir execv ("/bin/domainname", argv);
831cdf0e10cSrcweir // arriving here means exec failed
832cdf0e10cSrcweir _exit(-1);
833cdf0e10cSrcweir }
834cdf0e10cSrcweir else if (pid > 0)
835cdf0e10cSrcweir {
836cdf0e10cSrcweir sal_Int32 k = 0, n = bufsiz;
837cdf0e10cSrcweir
838cdf0e10cSrcweir close (p[1]);
839cdf0e10cSrcweir if ((k = read (p[0], buffer, n - 1)) > 0)
840cdf0e10cSrcweir {
841cdf0e10cSrcweir buffer[k] = 0;
842cdf0e10cSrcweir if (buffer[k - 1] == '\n')
843cdf0e10cSrcweir buffer[k - 1] = 0;
844cdf0e10cSrcweir result = sal_True;
845cdf0e10cSrcweir }
846cdf0e10cSrcweir close (p[0]);
847cdf0e10cSrcweir waitpid (pid, &nStatus, 0);
848cdf0e10cSrcweir }
849cdf0e10cSrcweir else
850cdf0e10cSrcweir {
851cdf0e10cSrcweir close (p[0]);
852cdf0e10cSrcweir close (p[1]);
853cdf0e10cSrcweir }
854cdf0e10cSrcweir }
855cdf0e10cSrcweir return (result);
856cdf0e10cSrcweir }
857cdf0e10cSrcweir
_osl_getFullQualifiedDomainName(const sal_Char * pHostName)858cdf0e10cSrcweir static sal_Char* _osl_getFullQualifiedDomainName (const sal_Char *pHostName)
859cdf0e10cSrcweir {
860cdf0e10cSrcweir # define DOMAINNAME_LENGTH 512
861cdf0e10cSrcweir sal_uInt32 nLengthOfHostName;
862cdf0e10cSrcweir static sal_uInt32 nLengthOfDomainName = 0;
863cdf0e10cSrcweir static sal_Char *pDomainName = NULL;
864cdf0e10cSrcweir
865cdf0e10cSrcweir sal_Char *pFullQualifiedName;
866cdf0e10cSrcweir #if 0 /* OBSOLETE */
867cdf0e10cSrcweir FILE *pPipeToDomainnameExe;
868cdf0e10cSrcweir #endif /* OBSOLETE */
869cdf0e10cSrcweir
870cdf0e10cSrcweir /* get a '\0' terminated domainname */
871cdf0e10cSrcweir
872cdf0e10cSrcweir /* read default domainname default from environment */
873cdf0e10cSrcweir if (nLengthOfDomainName == 0)
874cdf0e10cSrcweir {
875cdf0e10cSrcweir sal_Char *pEnvDomain;
876cdf0e10cSrcweir
877cdf0e10cSrcweir pEnvDomain = getenv ("STAR_OVERRIDE_DOMAINNAME");
878cdf0e10cSrcweir if (pEnvDomain)
879cdf0e10cSrcweir {
880cdf0e10cSrcweir pDomainName = strdup (pEnvDomain);
881cdf0e10cSrcweir nLengthOfDomainName = strlen (pDomainName);
882cdf0e10cSrcweir }
883cdf0e10cSrcweir }
884cdf0e10cSrcweir
885cdf0e10cSrcweir #if 1 /* NEW */
886cdf0e10cSrcweir if (nLengthOfDomainName == 0)
887cdf0e10cSrcweir {
888cdf0e10cSrcweir sal_Char pDomainNameBuffer[ DOMAINNAME_LENGTH ];
889cdf0e10cSrcweir
890cdf0e10cSrcweir pDomainNameBuffer[0] = '\0';
891cdf0e10cSrcweir
892cdf0e10cSrcweir if (_osl_getDomainName (pDomainNameBuffer, DOMAINNAME_LENGTH))
893cdf0e10cSrcweir {
894cdf0e10cSrcweir pDomainName = strdup (pDomainNameBuffer);
895cdf0e10cSrcweir nLengthOfDomainName = strlen (pDomainName);
896cdf0e10cSrcweir }
897cdf0e10cSrcweir }
898cdf0e10cSrcweir
899cdf0e10cSrcweir #endif /* NEW */
900cdf0e10cSrcweir #if 0 /* OBSOLETE */
901cdf0e10cSrcweir #ifdef SCO
902cdf0e10cSrcweir
903cdf0e10cSrcweir /* call 'domainname > /usr/tmp/some-tmp-file', since
904cdf0e10cSrcweir popen read pclose do block or core-dump,
905cdf0e10cSrcweir (even the pipe-stuff that comes with pthreads) */
906cdf0e10cSrcweir if (nLengthOfDomainName == 0)
907cdf0e10cSrcweir {
908cdf0e10cSrcweir sal_Char tmp_name[ L_tmpnam ];
909cdf0e10cSrcweir FILE *tmp_file;
910cdf0e10cSrcweir sal_Char domain_call [ L_tmpnam + 16 ] = "domainname > ";
911cdf0e10cSrcweir
912cdf0e10cSrcweir tmp_name[0] = '\0';
913cdf0e10cSrcweir
914cdf0e10cSrcweir tmpnam ( tmp_name );
915cdf0e10cSrcweir strcat ( domain_call, tmp_name );
916cdf0e10cSrcweir if ( (system ( domain_call ) == 0)
917cdf0e10cSrcweir && ((tmp_file = fopen( tmp_name, "r" )) != NULL ) )
918cdf0e10cSrcweir {
919cdf0e10cSrcweir sal_Char pDomainNameBuffer[ DOMAINNAME_LENGTH ];
920cdf0e10cSrcweir
921cdf0e10cSrcweir pDomainNameBuffer[0] = '\0';
922cdf0e10cSrcweir
923cdf0e10cSrcweir if ( fgets ( pDomainNameBuffer, DOMAINNAME_LENGTH, tmp_file ) )
924cdf0e10cSrcweir {
925cdf0e10cSrcweir pDomainName = strdup( pDomainNameBuffer );
926cdf0e10cSrcweir nLengthOfDomainName = strlen( pDomainName );
927cdf0e10cSrcweir if ( ( nLengthOfDomainName > 0 )
928cdf0e10cSrcweir && ( pDomainName[ nLengthOfDomainName - 1] == '\n' ) )
929cdf0e10cSrcweir pDomainName[ --nLengthOfDomainName ] = '\0';
930cdf0e10cSrcweir }
931cdf0e10cSrcweir fclose ( tmp_file );
932cdf0e10cSrcweir }
933cdf0e10cSrcweir unlink( tmp_name );
934cdf0e10cSrcweir }
935cdf0e10cSrcweir
936cdf0e10cSrcweir #else /* !SCO */
937cdf0e10cSrcweir
938cdf0e10cSrcweir /* read the domainname from pipe to the program domainname */
939cdf0e10cSrcweir if ( (nLengthOfDomainName == 0)
940cdf0e10cSrcweir && (pPipeToDomainnameExe = popen( "domainname", "r")) )
941cdf0e10cSrcweir {
942cdf0e10cSrcweir sal_Char c;
943cdf0e10cSrcweir sal_Char pDomainNameBuffer[ DOMAINNAME_LENGTH ];
944cdf0e10cSrcweir sal_Char *pDomainNamePointer;
945cdf0e10cSrcweir
946cdf0e10cSrcweir pDomainNameBuffer[0] = '\0';
947cdf0e10cSrcweir
948cdf0e10cSrcweir pDomainNamePointer = pDomainNameBuffer;
949cdf0e10cSrcweir while ( ((c = getc( pPipeToDomainnameExe )) != EOF)
950cdf0e10cSrcweir && (nLengthOfDomainName < (DOMAINNAME_LENGTH - 1)) )
951cdf0e10cSrcweir {
952cdf0e10cSrcweir if (! isspace(c))
953cdf0e10cSrcweir {
954cdf0e10cSrcweir nLengthOfDomainName++ ;
955cdf0e10cSrcweir *pDomainNamePointer++ = (sal_Char)c;
956cdf0e10cSrcweir }
957cdf0e10cSrcweir }
958cdf0e10cSrcweir *pDomainNamePointer = '\0';
959cdf0e10cSrcweir pDomainName = strdup( pDomainNameBuffer );
960cdf0e10cSrcweir
961cdf0e10cSrcweir pclose( pPipeToDomainnameExe );
962cdf0e10cSrcweir }
963cdf0e10cSrcweir
964cdf0e10cSrcweir #endif /* !SCO */
965cdf0e10cSrcweir #endif /* OBSOLETE */
966cdf0e10cSrcweir
967cdf0e10cSrcweir /* compose hostname and domainname */
968cdf0e10cSrcweir nLengthOfHostName = strlen( pHostName );
969cdf0e10cSrcweir pFullQualifiedName = (sal_Char*) malloc( (nLengthOfHostName + 1
970cdf0e10cSrcweir + nLengthOfDomainName + 1) * sizeof(sal_Char) );
971cdf0e10cSrcweir memcpy( pFullQualifiedName, pHostName,
972cdf0e10cSrcweir (nLengthOfHostName + 1) * sizeof(sal_Char) );
973cdf0e10cSrcweir
974cdf0e10cSrcweir if ( nLengthOfDomainName > 0 )
975cdf0e10cSrcweir {
976cdf0e10cSrcweir /* fqdn = hostname + '.' + domainname + '\0' */
977cdf0e10cSrcweir pFullQualifiedName[ nLengthOfHostName ] = '.';
978cdf0e10cSrcweir memcpy( pFullQualifiedName + nLengthOfHostName + 1, pDomainName,
979cdf0e10cSrcweir nLengthOfDomainName + 1 );
980cdf0e10cSrcweir }
981cdf0e10cSrcweir
982cdf0e10cSrcweir /* check whether full-qualified name and hostname point to the same host
983cdf0e10cSrcweir * should almost always be true */
984cdf0e10cSrcweir if ( nLengthOfDomainName > 0 )
985cdf0e10cSrcweir {
986cdf0e10cSrcweir struct hostent *pQualifiedHostByName;
987cdf0e10cSrcweir struct hostent *pHostByName;
988cdf0e10cSrcweir sal_Bool bHostsAreEqual;
989cdf0e10cSrcweir
990cdf0e10cSrcweir /* buffer for calls to reentrant version of gethostbyname */
991cdf0e10cSrcweir struct hostent aHostByName, aQualifiedHostByName;
992cdf0e10cSrcweir sal_Char pHostBuffer[ MAX_HOSTBUFFER_SIZE ];
993cdf0e10cSrcweir sal_Char pQualifiedHostBuffer[ MAX_HOSTBUFFER_SIZE ];
994cdf0e10cSrcweir int nErrorNo;
995cdf0e10cSrcweir
996cdf0e10cSrcweir pHostBuffer[0] = '\0';
997cdf0e10cSrcweir pQualifiedHostBuffer[0] = '\0';
998cdf0e10cSrcweir
999cdf0e10cSrcweir /* get list of addresses */
1000cdf0e10cSrcweir pQualifiedHostByName = _osl_gethostbyname_r (
1001cdf0e10cSrcweir pFullQualifiedName,
1002cdf0e10cSrcweir &aQualifiedHostByName, pQualifiedHostBuffer,
1003cdf0e10cSrcweir sizeof(pQualifiedHostBuffer), &nErrorNo );
1004cdf0e10cSrcweir pHostByName = _osl_gethostbyname_r (
1005cdf0e10cSrcweir pHostName,
1006cdf0e10cSrcweir &aHostByName, pHostBuffer,
1007cdf0e10cSrcweir sizeof(pHostBuffer), &nErrorNo );
1008cdf0e10cSrcweir
1009cdf0e10cSrcweir /* compare addresses */
1010cdf0e10cSrcweir bHostsAreEqual = sal_False;
1011cdf0e10cSrcweir if ( pQualifiedHostByName && pHostByName )
1012cdf0e10cSrcweir {
1013cdf0e10cSrcweir sal_Char **p, **q;
1014cdf0e10cSrcweir struct in_addr in;
1015cdf0e10cSrcweir
1016cdf0e10cSrcweir /* lists are expected to be (very) short */
1017cdf0e10cSrcweir for ( p = pQualifiedHostByName->h_addr_list; *p != NULL; p++ )
1018cdf0e10cSrcweir {
1019cdf0e10cSrcweir for ( q = pHostByName->h_addr_list; *q != NULL; q++ )
1020cdf0e10cSrcweir {
1021cdf0e10cSrcweir /* in.s_addr may be in_addr_t or uint32_t or heaven knows */
1022cdf0e10cSrcweir if ( memcmp( *p, *q, sizeof(in.s_addr) ) == 0 )
1023cdf0e10cSrcweir {
1024cdf0e10cSrcweir bHostsAreEqual = sal_True;
1025cdf0e10cSrcweir break;
1026cdf0e10cSrcweir }
1027cdf0e10cSrcweir }
1028cdf0e10cSrcweir if ( bHostsAreEqual )
1029cdf0e10cSrcweir break;
1030cdf0e10cSrcweir }
1031cdf0e10cSrcweir }
1032cdf0e10cSrcweir
1033cdf0e10cSrcweir /* very strange case, but have to believe it: reduce the
1034cdf0e10cSrcweir * full qualified name to the unqualified host name */
1035cdf0e10cSrcweir if ( !bHostsAreEqual )
1036cdf0e10cSrcweir {
1037cdf0e10cSrcweir OSL_TRACE("_osl_getFullQualifiedDomainName: "
1038cdf0e10cSrcweir "suspect FQDN: %s\n", pFullQualifiedName);
1039cdf0e10cSrcweir
1040cdf0e10cSrcweir pFullQualifiedName[ nLengthOfHostName ] = '\0';
1041cdf0e10cSrcweir pFullQualifiedName = (sal_Char*)realloc ( pFullQualifiedName,
1042cdf0e10cSrcweir (nLengthOfHostName + 1) * sizeof( sal_Char ));
1043cdf0e10cSrcweir }
1044cdf0e10cSrcweir }
1045cdf0e10cSrcweir
1046cdf0e10cSrcweir /* always return a hostname looked up as carefully as possible
1047cdf0e10cSrcweir * this string must be freed by the caller */
1048cdf0e10cSrcweir return pFullQualifiedName;
1049cdf0e10cSrcweir }
1050cdf0e10cSrcweir
1051cdf0e10cSrcweir /*****************************************************************************/
1052cdf0e10cSrcweir /* _osl_isFullQualifiedDomainName */
1053cdf0e10cSrcweir /*****************************************************************************/
_osl_isFullQualifiedDomainName(const sal_Char * pHostName)1054cdf0e10cSrcweir static sal_Bool _osl_isFullQualifiedDomainName (const sal_Char *pHostName)
1055cdf0e10cSrcweir {
1056cdf0e10cSrcweir /* a FQDN (aka 'hostname.domain.top_level_domain' )
1057cdf0e10cSrcweir * is a name which contains a dot '.' in it ( would
1058cdf0e10cSrcweir * match as well for 'hostname.' but is good enough
1059cdf0e10cSrcweir * for now )*/
1060cdf0e10cSrcweir return (sal_Bool)( strchr( pHostName, (int)'.' ) != NULL );
1061cdf0e10cSrcweir }
1062cdf0e10cSrcweir
1063cdf0e10cSrcweir /*****************************************************************************/
1064cdf0e10cSrcweir /* oslHostAddr */
1065cdf0e10cSrcweir /*****************************************************************************/
1066cdf0e10cSrcweir struct oslHostAddrImpl
1067cdf0e10cSrcweir {
1068cdf0e10cSrcweir sal_Char *pHostName;
1069cdf0e10cSrcweir oslSocketAddr pSockAddr;
1070cdf0e10cSrcweir };
1071cdf0e10cSrcweir
_osl_hostentToHostAddr(const struct hostent * he)1072cdf0e10cSrcweir static oslHostAddr _osl_hostentToHostAddr (const struct hostent *he)
1073cdf0e10cSrcweir {
1074cdf0e10cSrcweir oslHostAddr pAddr= NULL;
1075cdf0e10cSrcweir oslSocketAddr pSockAddr = 0;
1076cdf0e10cSrcweir
1077cdf0e10cSrcweir sal_Char *cn;
1078cdf0e10cSrcweir
1079cdf0e10cSrcweir if ((he == NULL) || (he->h_name == NULL) || (he->h_addr_list[0] == NULL))
1080cdf0e10cSrcweir return ((oslHostAddr)NULL);
1081cdf0e10cSrcweir
1082cdf0e10cSrcweir if (_osl_isFullQualifiedDomainName(he->h_name))
1083cdf0e10cSrcweir {
1084cdf0e10cSrcweir cn= (sal_Char *)malloc(strlen (he->h_name) + 1);
1085cdf0e10cSrcweir OSL_ASSERT(cn);
1086cdf0e10cSrcweir if (cn == NULL)
1087cdf0e10cSrcweir return ((oslHostAddr)NULL);
1088cdf0e10cSrcweir
1089cdf0e10cSrcweir strcpy(cn, he->h_name);
1090cdf0e10cSrcweir }
1091cdf0e10cSrcweir else
1092cdf0e10cSrcweir {
1093cdf0e10cSrcweir cn =_osl_getFullQualifiedDomainName (he->h_name);
1094cdf0e10cSrcweir OSL_ASSERT(cn);
1095cdf0e10cSrcweir if (cn == NULL)
1096cdf0e10cSrcweir return ((oslHostAddr)NULL);
1097cdf0e10cSrcweir }
1098cdf0e10cSrcweir
1099cdf0e10cSrcweir pSockAddr = __osl_createSocketAddr();
1100cdf0e10cSrcweir OSL_ASSERT(pSockAddr);
1101cdf0e10cSrcweir if (pSockAddr == NULL)
1102cdf0e10cSrcweir {
1103cdf0e10cSrcweir free(cn);
1104cdf0e10cSrcweir return ((oslHostAddr)NULL);
1105cdf0e10cSrcweir }
1106cdf0e10cSrcweir
1107cdf0e10cSrcweir pSockAddr->m_sockaddr.sa_family= he->h_addrtype;
1108cdf0e10cSrcweir if (pSockAddr->m_sockaddr.sa_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
1109cdf0e10cSrcweir {
1110cdf0e10cSrcweir struct sockaddr_in *sin= (struct sockaddr_in *)&(pSockAddr->m_sockaddr);
1111cdf0e10cSrcweir memcpy (
1112cdf0e10cSrcweir &(sin->sin_addr.s_addr),
1113cdf0e10cSrcweir he->h_addr_list[0],
1114cdf0e10cSrcweir he->h_length);
1115cdf0e10cSrcweir }
1116cdf0e10cSrcweir else
1117cdf0e10cSrcweir {
1118cdf0e10cSrcweir /* unknown address family */
1119cdf0e10cSrcweir /* future extensions for new families might be implemented here */
1120cdf0e10cSrcweir
1121cdf0e10cSrcweir OSL_TRACE("_osl_hostentToHostAddr: unknown address family.\n");
1122cdf0e10cSrcweir OSL_ASSERT(sal_False);
1123cdf0e10cSrcweir
1124cdf0e10cSrcweir __osl_destroySocketAddr( pSockAddr );
1125cdf0e10cSrcweir free (cn);
1126cdf0e10cSrcweir return ((oslHostAddr)NULL);
1127cdf0e10cSrcweir }
1128cdf0e10cSrcweir
1129cdf0e10cSrcweir pAddr= (oslHostAddr) malloc(sizeof(struct oslHostAddrImpl));
1130cdf0e10cSrcweir OSL_ASSERT(pAddr);
1131cdf0e10cSrcweir if (pAddr == NULL)
1132cdf0e10cSrcweir {
1133cdf0e10cSrcweir __osl_destroySocketAddr( pSockAddr );
1134cdf0e10cSrcweir free (cn);
1135cdf0e10cSrcweir return ((oslHostAddr)NULL);
1136cdf0e10cSrcweir }
1137cdf0e10cSrcweir
1138cdf0e10cSrcweir pAddr->pHostName= cn;
1139cdf0e10cSrcweir pAddr->pSockAddr= pSockAddr;
1140cdf0e10cSrcweir
1141cdf0e10cSrcweir return pAddr;
1142cdf0e10cSrcweir }
1143cdf0e10cSrcweir
1144cdf0e10cSrcweir /*****************************************************************************/
1145cdf0e10cSrcweir /* osl_createHostAddr */
1146cdf0e10cSrcweir /*****************************************************************************/
osl_createHostAddr(rtl_uString * ustrHostname,const oslSocketAddr Addr)1147cdf0e10cSrcweir oslHostAddr SAL_CALL osl_createHostAddr (
1148cdf0e10cSrcweir rtl_uString *ustrHostname,
1149cdf0e10cSrcweir const oslSocketAddr Addr)
1150cdf0e10cSrcweir {
1151cdf0e10cSrcweir oslHostAddr HostAddr;
1152cdf0e10cSrcweir rtl_String* strHostname=0;
1153cdf0e10cSrcweir sal_Char* pszHostName=0;
1154cdf0e10cSrcweir
1155cdf0e10cSrcweir if ( ustrHostname != 0 )
1156cdf0e10cSrcweir {
1157cdf0e10cSrcweir rtl_uString2String( &strHostname,
1158cdf0e10cSrcweir rtl_uString_getStr(ustrHostname),
1159cdf0e10cSrcweir rtl_uString_getLength(ustrHostname),
1160cdf0e10cSrcweir RTL_TEXTENCODING_UTF8,
1161cdf0e10cSrcweir OUSTRING_TO_OSTRING_CVTFLAGS );
1162cdf0e10cSrcweir pszHostName = rtl_string_getStr(strHostname);
1163cdf0e10cSrcweir }
1164cdf0e10cSrcweir
1165cdf0e10cSrcweir HostAddr = osl_psz_createHostAddr(pszHostName,Addr);
1166cdf0e10cSrcweir
1167cdf0e10cSrcweir if ( strHostname != 0 )
1168cdf0e10cSrcweir {
1169cdf0e10cSrcweir rtl_string_release(strHostname);
1170cdf0e10cSrcweir }
1171cdf0e10cSrcweir
1172cdf0e10cSrcweir return HostAddr;
1173cdf0e10cSrcweir }
1174cdf0e10cSrcweir
osl_psz_createHostAddr(const sal_Char * pszHostname,const oslSocketAddr pAddr)1175cdf0e10cSrcweir oslHostAddr SAL_CALL osl_psz_createHostAddr (
1176cdf0e10cSrcweir const sal_Char *pszHostname,
1177cdf0e10cSrcweir const oslSocketAddr pAddr)
1178cdf0e10cSrcweir {
1179cdf0e10cSrcweir oslHostAddr pHostAddr;
1180cdf0e10cSrcweir sal_Char *cn;
1181cdf0e10cSrcweir
1182cdf0e10cSrcweir OSL_ASSERT(pszHostname && pAddr);
1183cdf0e10cSrcweir if ((pszHostname == NULL) || (pAddr == NULL))
1184cdf0e10cSrcweir return ((oslHostAddr)NULL);
1185cdf0e10cSrcweir
1186cdf0e10cSrcweir cn = (sal_Char *)malloc(strlen (pszHostname) + 1);
1187cdf0e10cSrcweir OSL_ASSERT(cn);
1188cdf0e10cSrcweir if (cn == NULL)
1189cdf0e10cSrcweir return ((oslHostAddr)NULL);
1190cdf0e10cSrcweir
1191cdf0e10cSrcweir strcpy (cn, pszHostname);
1192cdf0e10cSrcweir
1193cdf0e10cSrcweir pHostAddr= (oslHostAddr) malloc(sizeof(struct oslHostAddrImpl));
1194cdf0e10cSrcweir OSL_ASSERT(pHostAddr);
1195cdf0e10cSrcweir if (pHostAddr == NULL)
1196cdf0e10cSrcweir {
1197cdf0e10cSrcweir free (cn);
1198cdf0e10cSrcweir return ((oslHostAddr)NULL);
1199cdf0e10cSrcweir }
1200cdf0e10cSrcweir
1201cdf0e10cSrcweir pHostAddr->pHostName= cn;
1202cdf0e10cSrcweir pHostAddr->pSockAddr= osl_copySocketAddr( pAddr );
1203cdf0e10cSrcweir
1204cdf0e10cSrcweir return pHostAddr;
1205cdf0e10cSrcweir }
1206cdf0e10cSrcweir
1207cdf0e10cSrcweir /*****************************************************************************/
1208cdf0e10cSrcweir /* osl_createHostAddrByName */
1209cdf0e10cSrcweir /*****************************************************************************/
osl_createHostAddrByName(rtl_uString * ustrHostname)1210cdf0e10cSrcweir oslHostAddr SAL_CALL osl_createHostAddrByName(rtl_uString *ustrHostname)
1211cdf0e10cSrcweir {
1212cdf0e10cSrcweir oslHostAddr HostAddr;
1213cdf0e10cSrcweir rtl_String* strHostname=0;
1214cdf0e10cSrcweir sal_Char* pszHostName=0;
1215cdf0e10cSrcweir
1216cdf0e10cSrcweir if ( ustrHostname != 0 )
1217cdf0e10cSrcweir {
1218cdf0e10cSrcweir rtl_uString2String( &strHostname,
1219cdf0e10cSrcweir rtl_uString_getStr(ustrHostname),
1220cdf0e10cSrcweir rtl_uString_getLength(ustrHostname),
1221cdf0e10cSrcweir RTL_TEXTENCODING_UTF8,
1222cdf0e10cSrcweir OUSTRING_TO_OSTRING_CVTFLAGS );
1223cdf0e10cSrcweir pszHostName=rtl_string_getStr(strHostname);
1224cdf0e10cSrcweir }
1225cdf0e10cSrcweir
1226cdf0e10cSrcweir HostAddr = osl_psz_createHostAddrByName(pszHostName);
1227cdf0e10cSrcweir
1228cdf0e10cSrcweir if ( strHostname != 0 )
1229cdf0e10cSrcweir {
1230cdf0e10cSrcweir rtl_string_release(strHostname);
1231cdf0e10cSrcweir }
1232cdf0e10cSrcweir
1233cdf0e10cSrcweir return HostAddr;
1234cdf0e10cSrcweir }
1235cdf0e10cSrcweir
osl_psz_createHostAddrByName(const sal_Char * pszHostname)1236cdf0e10cSrcweir oslHostAddr SAL_CALL osl_psz_createHostAddrByName (const sal_Char *pszHostname)
1237cdf0e10cSrcweir {
1238cdf0e10cSrcweir struct hostent *he;
1239cdf0e10cSrcweir oslHostAddr addr;
1240cdf0e10cSrcweir
1241cdf0e10cSrcweir static oslMutex mutex = NULL;
1242cdf0e10cSrcweir
1243cdf0e10cSrcweir if (mutex == NULL)
1244cdf0e10cSrcweir mutex = osl_createMutex();
1245cdf0e10cSrcweir
1246cdf0e10cSrcweir osl_acquireMutex(mutex);
1247cdf0e10cSrcweir
1248cdf0e10cSrcweir he = gethostbyname((sal_Char *)pszHostname);
1249cdf0e10cSrcweir addr = _osl_hostentToHostAddr (he);
1250cdf0e10cSrcweir
1251cdf0e10cSrcweir osl_releaseMutex(mutex);
1252cdf0e10cSrcweir
1253cdf0e10cSrcweir return addr;
1254cdf0e10cSrcweir }
1255cdf0e10cSrcweir
1256cdf0e10cSrcweir /*****************************************************************************/
1257cdf0e10cSrcweir /* osl_createHostAddrByAddr */
1258cdf0e10cSrcweir /*****************************************************************************/
osl_createHostAddrByAddr(const oslSocketAddr pAddr)1259cdf0e10cSrcweir oslHostAddr SAL_CALL osl_createHostAddrByAddr (const oslSocketAddr pAddr)
1260cdf0e10cSrcweir {
1261cdf0e10cSrcweir OSL_ASSERT(pAddr);
1262cdf0e10cSrcweir
1263cdf0e10cSrcweir if (pAddr == NULL)
1264cdf0e10cSrcweir return ((oslHostAddr)NULL);
1265cdf0e10cSrcweir
1266cdf0e10cSrcweir if (pAddr->m_sockaddr.sa_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
1267cdf0e10cSrcweir {
1268cdf0e10cSrcweir const struct sockaddr_in *sin= (const struct sockaddr_in *)&(pAddr->m_sockaddr);
1269cdf0e10cSrcweir struct hostent *he;
1270cdf0e10cSrcweir
1271cdf0e10cSrcweir if (sin->sin_addr.s_addr == htonl(INADDR_ANY))
1272cdf0e10cSrcweir return ((oslHostAddr)NULL);
1273cdf0e10cSrcweir
1274cdf0e10cSrcweir he= gethostbyaddr((sal_Char *)&(sin->sin_addr),
1275cdf0e10cSrcweir sizeof (sin->sin_addr),
1276cdf0e10cSrcweir sin->sin_family);
1277cdf0e10cSrcweir return _osl_hostentToHostAddr (he);
1278cdf0e10cSrcweir }
1279cdf0e10cSrcweir
1280cdf0e10cSrcweir return ((oslHostAddr)NULL);
1281cdf0e10cSrcweir }
1282cdf0e10cSrcweir
1283cdf0e10cSrcweir /*****************************************************************************/
1284cdf0e10cSrcweir /* osl_copyHostAddr */
1285cdf0e10cSrcweir /*****************************************************************************/
osl_copyHostAddr(const oslHostAddr pAddr)1286cdf0e10cSrcweir oslHostAddr SAL_CALL osl_copyHostAddr (const oslHostAddr pAddr)
1287cdf0e10cSrcweir {
1288cdf0e10cSrcweir OSL_ASSERT(pAddr);
1289cdf0e10cSrcweir
1290cdf0e10cSrcweir if (pAddr)
1291cdf0e10cSrcweir return osl_psz_createHostAddr (pAddr->pHostName, pAddr->pSockAddr);
1292cdf0e10cSrcweir else
1293cdf0e10cSrcweir return ((oslHostAddr)NULL);
1294cdf0e10cSrcweir }
1295cdf0e10cSrcweir
1296cdf0e10cSrcweir /*****************************************************************************/
1297cdf0e10cSrcweir /* osl_getHostnameOfHostAddr */
1298cdf0e10cSrcweir /*****************************************************************************/
osl_getHostnameOfHostAddr(const oslHostAddr Addr,rtl_uString ** ustrHostname)1299cdf0e10cSrcweir void SAL_CALL osl_getHostnameOfHostAddr (
1300cdf0e10cSrcweir const oslHostAddr Addr,
1301cdf0e10cSrcweir rtl_uString **ustrHostname)
1302cdf0e10cSrcweir {
1303cdf0e10cSrcweir const sal_Char* pHostname=0;
1304cdf0e10cSrcweir
1305cdf0e10cSrcweir pHostname = osl_psz_getHostnameOfHostAddr(Addr);
1306cdf0e10cSrcweir
1307cdf0e10cSrcweir rtl_uString_newFromAscii (ustrHostname, pHostname);
1308cdf0e10cSrcweir
1309cdf0e10cSrcweir return;
1310cdf0e10cSrcweir }
1311cdf0e10cSrcweir
osl_psz_getHostnameOfHostAddr(const oslHostAddr pAddr)1312cdf0e10cSrcweir const sal_Char* SAL_CALL osl_psz_getHostnameOfHostAddr (const oslHostAddr pAddr)
1313cdf0e10cSrcweir {
1314cdf0e10cSrcweir OSL_ASSERT(pAddr);
1315cdf0e10cSrcweir
1316cdf0e10cSrcweir if (pAddr)
1317cdf0e10cSrcweir return pAddr->pHostName;
1318cdf0e10cSrcweir else
1319cdf0e10cSrcweir return NULL;
1320cdf0e10cSrcweir }
1321cdf0e10cSrcweir
1322cdf0e10cSrcweir /*****************************************************************************/
1323cdf0e10cSrcweir /* osl_getSocketAddrOfHostAddr */
1324cdf0e10cSrcweir /*****************************************************************************/
osl_getSocketAddrOfHostAddr(const oslHostAddr pAddr)1325cdf0e10cSrcweir oslSocketAddr SAL_CALL osl_getSocketAddrOfHostAddr (const oslHostAddr pAddr)
1326cdf0e10cSrcweir {
1327cdf0e10cSrcweir OSL_ASSERT(pAddr);
1328cdf0e10cSrcweir
1329cdf0e10cSrcweir if (pAddr)
1330cdf0e10cSrcweir return ((oslSocketAddr)(pAddr->pSockAddr));
1331cdf0e10cSrcweir else
1332cdf0e10cSrcweir return NULL;
1333cdf0e10cSrcweir }
1334cdf0e10cSrcweir
1335cdf0e10cSrcweir /*****************************************************************************/
1336cdf0e10cSrcweir /* osl_destroyHostAddr */
1337cdf0e10cSrcweir /*****************************************************************************/
osl_destroyHostAddr(oslHostAddr pAddr)1338cdf0e10cSrcweir void SAL_CALL osl_destroyHostAddr (oslHostAddr pAddr)
1339cdf0e10cSrcweir {
1340cdf0e10cSrcweir if (pAddr)
1341cdf0e10cSrcweir {
1342cdf0e10cSrcweir if (pAddr->pHostName)
1343cdf0e10cSrcweir free (pAddr->pHostName);
1344cdf0e10cSrcweir if (pAddr->pSockAddr)
1345cdf0e10cSrcweir osl_destroySocketAddr (pAddr->pSockAddr);
1346cdf0e10cSrcweir free (pAddr);
1347cdf0e10cSrcweir }
1348cdf0e10cSrcweir }
1349cdf0e10cSrcweir
1350cdf0e10cSrcweir /*****************************************************************************/
1351cdf0e10cSrcweir /* osl_getLocalHostname */
1352cdf0e10cSrcweir /*****************************************************************************/
osl_getLocalHostname(rtl_uString ** ustrLocalHostname)1353cdf0e10cSrcweir oslSocketResult SAL_CALL osl_getLocalHostname(rtl_uString **ustrLocalHostname)
1354cdf0e10cSrcweir {
1355cdf0e10cSrcweir oslSocketResult Result;
1356cdf0e10cSrcweir sal_Char pszHostname[1024];
1357cdf0e10cSrcweir
1358cdf0e10cSrcweir pszHostname[0] = '\0';
1359cdf0e10cSrcweir
1360cdf0e10cSrcweir Result = osl_psz_getLocalHostname(pszHostname,sizeof(pszHostname));
1361cdf0e10cSrcweir
1362cdf0e10cSrcweir rtl_uString_newFromAscii(ustrLocalHostname,pszHostname);
1363cdf0e10cSrcweir
1364cdf0e10cSrcweir return Result;
1365cdf0e10cSrcweir }
1366cdf0e10cSrcweir
osl_psz_getLocalHostname(sal_Char * pBuffer,sal_uInt32 nBufLen)1367cdf0e10cSrcweir oslSocketResult SAL_CALL osl_psz_getLocalHostname (
1368cdf0e10cSrcweir sal_Char *pBuffer, sal_uInt32 nBufLen)
1369cdf0e10cSrcweir {
1370cdf0e10cSrcweir static sal_Char LocalHostname[256] = "";
1371cdf0e10cSrcweir
1372cdf0e10cSrcweir if (strlen(LocalHostname) == 0)
1373cdf0e10cSrcweir {
1374cdf0e10cSrcweir const sal_Char *pStr;
1375cdf0e10cSrcweir
1376cdf0e10cSrcweir #ifdef SYSV
1377cdf0e10cSrcweir struct utsname uts;
1378cdf0e10cSrcweir
1379cdf0e10cSrcweir if (uname(&uts) < 0)
1380cdf0e10cSrcweir return osl_Socket_Error;
1381cdf0e10cSrcweir
1382cdf0e10cSrcweir if ((strlen(uts.nodename) + 1) > nBufLen)
1383cdf0e10cSrcweir return osl_Socket_Error;
1384cdf0e10cSrcweir
1385cdf0e10cSrcweir strncpy(LocalHostname, uts.nodename, sizeof( LocalHostname ));
1386cdf0e10cSrcweir #else /* BSD compatible */
1387cdf0e10cSrcweir
1388cdf0e10cSrcweir if (gethostname(LocalHostname, sizeof(LocalHostname)-1) != 0)
1389cdf0e10cSrcweir return osl_Socket_Error;
1390cdf0e10cSrcweir LocalHostname[sizeof(LocalHostname)-1] = 0;
1391cdf0e10cSrcweir #endif /* SYSV */
1392cdf0e10cSrcweir
1393cdf0e10cSrcweir /* check if we have an FQDN */
1394cdf0e10cSrcweir if (strchr(LocalHostname, '.') == NULL)
1395cdf0e10cSrcweir {
1396cdf0e10cSrcweir oslHostAddr Addr;
1397cdf0e10cSrcweir
1398cdf0e10cSrcweir /* no, determine it via dns */
1399cdf0e10cSrcweir Addr = osl_psz_createHostAddrByName(LocalHostname);
1400cdf0e10cSrcweir
1401cdf0e10cSrcweir if ((pStr = osl_psz_getHostnameOfHostAddr(Addr)) != NULL)
1402cdf0e10cSrcweir {
1403cdf0e10cSrcweir #if 0 /* OBSOLETE */
1404cdf0e10cSrcweir sal_Char* pChr;
1405cdf0e10cSrcweir #endif /* OBSOLETE */
1406cdf0e10cSrcweir strcpy(LocalHostname, pStr);
1407cdf0e10cSrcweir
1408cdf0e10cSrcweir #if 0 /* OBSOLETE */
1409cdf0e10cSrcweir /* already done by _osl_getFullQualifiedDomainName() with
1410cdf0e10cSrcweir much better heuristics, so this may be contraproductive */
1411cdf0e10cSrcweir
1412cdf0e10cSrcweir /* no FQDN, last try append domain name */
1413cdf0e10cSrcweir if ((pChr = strchr(LocalHostname, '.')) == NULL)
1414cdf0e10cSrcweir {
1415cdf0e10cSrcweir FILE *fp;
1416cdf0e10cSrcweir
1417cdf0e10cSrcweir pChr = &LocalHostname[strlen(LocalHostname)];
1418cdf0e10cSrcweir
1419cdf0e10cSrcweir if ( (fp = popen("domainname", "r")) != 0 )
1420cdf0e10cSrcweir {
1421cdf0e10cSrcweir int c;
1422cdf0e10cSrcweir
1423cdf0e10cSrcweir *pChr++ = '.';
1424cdf0e10cSrcweir
1425cdf0e10cSrcweir while ((c = getc(fp)) != EOF)
1426cdf0e10cSrcweir {
1427cdf0e10cSrcweir if (! isspace(c))
1428cdf0e10cSrcweir *pChr++ = (sal_Char)c;
1429cdf0e10cSrcweir }
1430cdf0e10cSrcweir
1431cdf0e10cSrcweir *pChr = '\0';
1432cdf0e10cSrcweir
1433cdf0e10cSrcweir fclose(fp);
1434cdf0e10cSrcweir }
1435cdf0e10cSrcweir else
1436cdf0e10cSrcweir LocalHostname[0] = '\0';
1437cdf0e10cSrcweir }
1438cdf0e10cSrcweir #endif /* OBSOLETE */
1439cdf0e10cSrcweir
1440cdf0e10cSrcweir }
1441cdf0e10cSrcweir osl_destroyHostAddr(Addr);
1442cdf0e10cSrcweir }
1443cdf0e10cSrcweir }
1444cdf0e10cSrcweir
1445cdf0e10cSrcweir if (strlen(LocalHostname) > 0)
1446cdf0e10cSrcweir {
1447cdf0e10cSrcweir strncpy(pBuffer, LocalHostname, nBufLen);
1448cdf0e10cSrcweir pBuffer[nBufLen - 1] = '\0';
1449cdf0e10cSrcweir
1450cdf0e10cSrcweir return osl_Socket_Ok;
1451cdf0e10cSrcweir }
1452cdf0e10cSrcweir
1453cdf0e10cSrcweir return osl_Socket_Error;
1454cdf0e10cSrcweir }
1455cdf0e10cSrcweir
1456cdf0e10cSrcweir /*****************************************************************************/
1457cdf0e10cSrcweir /* osl_resolveHostname */
1458cdf0e10cSrcweir /*****************************************************************************/
osl_resolveHostname(rtl_uString * ustrHostname)1459cdf0e10cSrcweir oslSocketAddr SAL_CALL osl_resolveHostname(rtl_uString *ustrHostname)
1460cdf0e10cSrcweir {
1461cdf0e10cSrcweir oslSocketAddr Addr;
1462cdf0e10cSrcweir rtl_String* strHostname=0;
1463cdf0e10cSrcweir sal_Char* pszHostName=0;
1464cdf0e10cSrcweir
1465cdf0e10cSrcweir if ( ustrHostname != 0 )
1466cdf0e10cSrcweir {
1467cdf0e10cSrcweir rtl_uString2String( &strHostname,
1468cdf0e10cSrcweir rtl_uString_getStr(ustrHostname),
1469cdf0e10cSrcweir rtl_uString_getLength(ustrHostname),
1470cdf0e10cSrcweir RTL_TEXTENCODING_UTF8,
1471cdf0e10cSrcweir OUSTRING_TO_OSTRING_CVTFLAGS );
1472cdf0e10cSrcweir pszHostName = rtl_string_getStr(strHostname);
1473cdf0e10cSrcweir }
1474cdf0e10cSrcweir
1475cdf0e10cSrcweir
1476cdf0e10cSrcweir Addr = osl_psz_resolveHostname(pszHostName);
1477cdf0e10cSrcweir
1478cdf0e10cSrcweir if ( strHostname != 0 )
1479cdf0e10cSrcweir {
1480cdf0e10cSrcweir rtl_string_release(strHostname);
1481cdf0e10cSrcweir }
1482cdf0e10cSrcweir
1483cdf0e10cSrcweir
1484cdf0e10cSrcweir return Addr;
1485cdf0e10cSrcweir }
1486cdf0e10cSrcweir
1487cdf0e10cSrcweir
osl_psz_resolveHostname(const sal_Char * pszHostname)1488cdf0e10cSrcweir oslSocketAddr SAL_CALL osl_psz_resolveHostname(const sal_Char* pszHostname)
1489cdf0e10cSrcweir {
1490cdf0e10cSrcweir struct oslHostAddrImpl *pAddr = (oslHostAddr)osl_psz_createHostAddrByName(pszHostname);
1491cdf0e10cSrcweir
1492cdf0e10cSrcweir if (pAddr)
1493cdf0e10cSrcweir {
1494cdf0e10cSrcweir oslSocketAddr SockAddr = osl_copySocketAddr(pAddr->pSockAddr);
1495cdf0e10cSrcweir
1496cdf0e10cSrcweir osl_destroyHostAddr(pAddr);
1497cdf0e10cSrcweir
1498cdf0e10cSrcweir return (SockAddr);
1499cdf0e10cSrcweir }
1500cdf0e10cSrcweir
1501cdf0e10cSrcweir return ((oslSocketAddr)NULL);
1502cdf0e10cSrcweir }
1503cdf0e10cSrcweir
1504cdf0e10cSrcweir /*****************************************************************************/
1505cdf0e10cSrcweir /* osl_getServicePort */
1506cdf0e10cSrcweir /*****************************************************************************/
osl_getServicePort(rtl_uString * ustrServicename,rtl_uString * ustrProtocol)1507cdf0e10cSrcweir sal_Int32 SAL_CALL osl_getServicePort(rtl_uString *ustrServicename, rtl_uString *ustrProtocol)
1508cdf0e10cSrcweir {
1509cdf0e10cSrcweir sal_Int32 nPort;
1510cdf0e10cSrcweir rtl_String* strServicename=0;
1511cdf0e10cSrcweir rtl_String* strProtocol=0;
1512cdf0e10cSrcweir sal_Char* pszServiceName=0;
1513cdf0e10cSrcweir sal_Char* pszProtocol=0;
1514cdf0e10cSrcweir
1515cdf0e10cSrcweir if ( ustrServicename != 0 )
1516cdf0e10cSrcweir {
1517cdf0e10cSrcweir rtl_uString2String( &strServicename,
1518cdf0e10cSrcweir rtl_uString_getStr(ustrServicename),
1519cdf0e10cSrcweir rtl_uString_getLength(ustrServicename),
1520cdf0e10cSrcweir RTL_TEXTENCODING_UTF8,
1521cdf0e10cSrcweir OUSTRING_TO_OSTRING_CVTFLAGS );
1522cdf0e10cSrcweir pszServiceName = rtl_string_getStr(strServicename);
1523cdf0e10cSrcweir }
1524cdf0e10cSrcweir
1525cdf0e10cSrcweir if ( ustrProtocol != 0 )
1526cdf0e10cSrcweir {
1527cdf0e10cSrcweir rtl_uString2String( &strProtocol,
1528cdf0e10cSrcweir rtl_uString_getStr(ustrProtocol),
1529cdf0e10cSrcweir rtl_uString_getLength(ustrProtocol),
1530cdf0e10cSrcweir RTL_TEXTENCODING_UTF8,
1531cdf0e10cSrcweir OUSTRING_TO_OSTRING_CVTFLAGS );
1532cdf0e10cSrcweir pszProtocol = rtl_string_getStr(strProtocol);
1533cdf0e10cSrcweir }
1534cdf0e10cSrcweir
1535cdf0e10cSrcweir nPort = osl_psz_getServicePort(pszServiceName,pszProtocol);
1536cdf0e10cSrcweir
1537cdf0e10cSrcweir if ( strServicename != 0 )
1538cdf0e10cSrcweir {
1539cdf0e10cSrcweir rtl_string_release(strServicename);
1540cdf0e10cSrcweir }
1541cdf0e10cSrcweir
1542cdf0e10cSrcweir if ( strProtocol != 0 )
1543cdf0e10cSrcweir {
1544cdf0e10cSrcweir rtl_string_release(strProtocol);
1545cdf0e10cSrcweir }
1546cdf0e10cSrcweir
1547cdf0e10cSrcweir
1548cdf0e10cSrcweir return nPort;
1549cdf0e10cSrcweir }
1550cdf0e10cSrcweir
1551cdf0e10cSrcweir
osl_psz_getServicePort(const sal_Char * pszServicename,const sal_Char * pszProtocol)1552cdf0e10cSrcweir sal_Int32 SAL_CALL osl_psz_getServicePort(const sal_Char* pszServicename,
1553cdf0e10cSrcweir const sal_Char* pszProtocol)
1554cdf0e10cSrcweir {
1555cdf0e10cSrcweir struct servent* ps;
1556cdf0e10cSrcweir
1557cdf0e10cSrcweir ps= getservbyname(pszServicename, pszProtocol);
1558cdf0e10cSrcweir
1559cdf0e10cSrcweir if (ps != 0)
1560cdf0e10cSrcweir return ntohs(ps->s_port);
1561cdf0e10cSrcweir
1562cdf0e10cSrcweir return OSL_INVALID_PORT;
1563cdf0e10cSrcweir }
1564cdf0e10cSrcweir
1565cdf0e10cSrcweir /*****************************************************************************/
1566cdf0e10cSrcweir /* osl_destroySocketAddr */
1567cdf0e10cSrcweir /*****************************************************************************/
osl_destroySocketAddr(oslSocketAddr pAddr)1568cdf0e10cSrcweir void SAL_CALL osl_destroySocketAddr(oslSocketAddr pAddr)
1569cdf0e10cSrcweir {
1570cdf0e10cSrcweir __osl_destroySocketAddr( pAddr );
1571cdf0e10cSrcweir }
1572cdf0e10cSrcweir
1573cdf0e10cSrcweir /*****************************************************************************/
1574cdf0e10cSrcweir /* osl_getFamilyOfSocketAddr */
1575cdf0e10cSrcweir /*****************************************************************************/
osl_getFamilyOfSocketAddr(oslSocketAddr pAddr)1576cdf0e10cSrcweir oslAddrFamily SAL_CALL osl_getFamilyOfSocketAddr(oslSocketAddr pAddr)
1577cdf0e10cSrcweir {
1578cdf0e10cSrcweir OSL_ASSERT(pAddr);
1579cdf0e10cSrcweir
1580cdf0e10cSrcweir if (pAddr)
1581cdf0e10cSrcweir return FAMILY_FROM_NATIVE(pAddr->m_sockaddr.sa_family);
1582cdf0e10cSrcweir else
1583cdf0e10cSrcweir return osl_Socket_FamilyInvalid;
1584cdf0e10cSrcweir }
1585cdf0e10cSrcweir
1586cdf0e10cSrcweir /*****************************************************************************/
1587cdf0e10cSrcweir /* osl_getInetPortOfSocketAddr */
1588cdf0e10cSrcweir /*****************************************************************************/
osl_getInetPortOfSocketAddr(oslSocketAddr pAddr)1589cdf0e10cSrcweir sal_Int32 SAL_CALL osl_getInetPortOfSocketAddr(oslSocketAddr pAddr)
1590cdf0e10cSrcweir {
1591cdf0e10cSrcweir OSL_ASSERT(pAddr);
1592cdf0e10cSrcweir if( pAddr )
1593cdf0e10cSrcweir {
1594cdf0e10cSrcweir struct sockaddr_in* pSystemInetAddr= (struct sockaddr_in*)&(pAddr->m_sockaddr);
1595cdf0e10cSrcweir
1596cdf0e10cSrcweir if ( pSystemInetAddr->sin_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
1597cdf0e10cSrcweir return ntohs(pSystemInetAddr->sin_port);
1598cdf0e10cSrcweir }
1599cdf0e10cSrcweir return OSL_INVALID_PORT;
1600cdf0e10cSrcweir }
1601cdf0e10cSrcweir
1602cdf0e10cSrcweir /*****************************************************************************/
1603cdf0e10cSrcweir /* osl_setInetPortOfSocketAddr */
1604cdf0e10cSrcweir /*****************************************************************************/
osl_setInetPortOfSocketAddr(oslSocketAddr pAddr,sal_Int32 Port)1605cdf0e10cSrcweir sal_Bool SAL_CALL osl_setInetPortOfSocketAddr(oslSocketAddr pAddr, sal_Int32 Port)
1606cdf0e10cSrcweir {
1607cdf0e10cSrcweir OSL_ASSERT(pAddr);
1608cdf0e10cSrcweir if( pAddr )
1609cdf0e10cSrcweir {
1610cdf0e10cSrcweir struct sockaddr_in* pSystemInetAddr= (struct sockaddr_in*)&(pAddr->m_sockaddr);
1611cdf0e10cSrcweir if ( pSystemInetAddr->sin_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
1612cdf0e10cSrcweir {
1613cdf0e10cSrcweir pSystemInetAddr->sin_port= htons((short)Port);
1614cdf0e10cSrcweir return sal_True;
1615cdf0e10cSrcweir }
1616cdf0e10cSrcweir }
1617cdf0e10cSrcweir
1618cdf0e10cSrcweir /* this is not a inet-addr => can't set port */
1619cdf0e10cSrcweir return sal_False;
1620cdf0e10cSrcweir }
1621cdf0e10cSrcweir
1622cdf0e10cSrcweir /*****************************************************************************/
1623cdf0e10cSrcweir /* osl_getHostnameOfSocketAddr */
1624cdf0e10cSrcweir /*****************************************************************************/
osl_getHostnameOfSocketAddr(oslSocketAddr Addr,rtl_uString ** ustrHostname)1625cdf0e10cSrcweir oslSocketResult SAL_CALL osl_getHostnameOfSocketAddr(oslSocketAddr Addr, rtl_uString **ustrHostname)
1626cdf0e10cSrcweir {
1627cdf0e10cSrcweir oslSocketResult Result;
1628cdf0e10cSrcweir sal_Char pszHostname[1024];
1629cdf0e10cSrcweir
1630cdf0e10cSrcweir pszHostname[0] = '\0';
1631cdf0e10cSrcweir
1632cdf0e10cSrcweir Result = osl_psz_getHostnameOfSocketAddr(Addr,pszHostname,sizeof(pszHostname));
1633cdf0e10cSrcweir
1634cdf0e10cSrcweir rtl_uString_newFromAscii(ustrHostname,pszHostname);
1635cdf0e10cSrcweir
1636cdf0e10cSrcweir return Result;
1637cdf0e10cSrcweir }
1638cdf0e10cSrcweir
1639cdf0e10cSrcweir
osl_psz_getHostnameOfSocketAddr(oslSocketAddr pAddr,sal_Char * pBuffer,sal_uInt32 BufferSize)1640cdf0e10cSrcweir oslSocketResult SAL_CALL osl_psz_getHostnameOfSocketAddr(oslSocketAddr pAddr,
1641cdf0e10cSrcweir sal_Char *pBuffer, sal_uInt32 BufferSize)
1642cdf0e10cSrcweir {
1643cdf0e10cSrcweir oslHostAddr pHostAddr= (oslHostAddr )osl_createHostAddrByAddr(pAddr);
1644cdf0e10cSrcweir
1645cdf0e10cSrcweir if (pHostAddr)
1646cdf0e10cSrcweir {
1647cdf0e10cSrcweir strncpy(pBuffer, pHostAddr->pHostName, BufferSize);
1648cdf0e10cSrcweir
1649cdf0e10cSrcweir pBuffer[BufferSize - 1] = '\0';
1650cdf0e10cSrcweir
1651cdf0e10cSrcweir osl_destroyHostAddr(pHostAddr);
1652cdf0e10cSrcweir
1653cdf0e10cSrcweir return osl_Socket_Ok;
1654cdf0e10cSrcweir }
1655cdf0e10cSrcweir
1656cdf0e10cSrcweir return osl_Socket_Error;
1657cdf0e10cSrcweir }
1658cdf0e10cSrcweir
1659cdf0e10cSrcweir /*****************************************************************************/
1660cdf0e10cSrcweir /* osl_getDottedInetAddrOfSocketAddr */
1661cdf0e10cSrcweir /*****************************************************************************/
osl_getDottedInetAddrOfSocketAddr(oslSocketAddr Addr,rtl_uString ** ustrDottedInetAddr)1662cdf0e10cSrcweir oslSocketResult SAL_CALL osl_getDottedInetAddrOfSocketAddr(oslSocketAddr Addr, rtl_uString **ustrDottedInetAddr)
1663cdf0e10cSrcweir {
1664cdf0e10cSrcweir oslSocketResult Result;
1665cdf0e10cSrcweir sal_Char pszDottedInetAddr[1024];
1666cdf0e10cSrcweir
1667cdf0e10cSrcweir pszDottedInetAddr[0] = '\0';
1668cdf0e10cSrcweir
1669cdf0e10cSrcweir Result = osl_psz_getDottedInetAddrOfSocketAddr(Addr,pszDottedInetAddr,sizeof(pszDottedInetAddr));
1670cdf0e10cSrcweir
1671cdf0e10cSrcweir rtl_uString_newFromAscii(ustrDottedInetAddr,pszDottedInetAddr);
1672cdf0e10cSrcweir
1673cdf0e10cSrcweir return Result;
1674cdf0e10cSrcweir
1675cdf0e10cSrcweir }
1676cdf0e10cSrcweir
osl_psz_getDottedInetAddrOfSocketAddr(oslSocketAddr pAddr,sal_Char * pBuffer,sal_uInt32 BufferSize)1677cdf0e10cSrcweir oslSocketResult SAL_CALL osl_psz_getDottedInetAddrOfSocketAddr(oslSocketAddr pAddr,
1678cdf0e10cSrcweir sal_Char *pBuffer, sal_uInt32 BufferSize)
1679cdf0e10cSrcweir {
1680cdf0e10cSrcweir OSL_ASSERT(pAddr);
1681cdf0e10cSrcweir
1682cdf0e10cSrcweir if( pAddr )
1683cdf0e10cSrcweir {
1684cdf0e10cSrcweir struct sockaddr_in* pSystemInetAddr = ( struct sockaddr_in * ) &(pAddr->m_sockaddr);
1685cdf0e10cSrcweir
1686cdf0e10cSrcweir if (pSystemInetAddr->sin_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
1687cdf0e10cSrcweir {
1688cdf0e10cSrcweir strncpy(pBuffer, inet_ntoa(pSystemInetAddr->sin_addr), BufferSize);
1689cdf0e10cSrcweir pBuffer[BufferSize - 1] = '\0';
1690cdf0e10cSrcweir
1691cdf0e10cSrcweir return osl_Socket_Ok;
1692cdf0e10cSrcweir }
1693cdf0e10cSrcweir }
1694cdf0e10cSrcweir
1695cdf0e10cSrcweir return osl_Socket_Error;
1696cdf0e10cSrcweir }
1697cdf0e10cSrcweir
1698cdf0e10cSrcweir #if 0 /* OBSOLETE */
1699cdf0e10cSrcweir /*****************************************************************************/
1700cdf0e10cSrcweir /* osl_getIpxNetNumber */
1701cdf0e10cSrcweir /*****************************************************************************/
1702cdf0e10cSrcweir oslSocketResult SAL_CALL osl_getIpxNetNumber(oslSocketAddr Addr,
1703cdf0e10cSrcweir oslSocketIpxNetNumber NetNumber)
1704cdf0e10cSrcweir
1705cdf0e10cSrcweir {
1706cdf0e10cSrcweir struct sockaddr_ipx* pAddr;
1707cdf0e10cSrcweir
1708cdf0e10cSrcweir pAddr= (struct sockaddr_ipx*)Addr;
1709cdf0e10cSrcweir
1710cdf0e10cSrcweir OSL_ASSERT(pAddr);
1711cdf0e10cSrcweir
1712cdf0e10cSrcweir if (pAddr && (pAddr->sa_family == FAMILY_TO_NATIVE(osl_Socket_FamilyIpx)))
1713cdf0e10cSrcweir {
1714cdf0e10cSrcweir memcpy(NetNumber, pAddr->sa_netnum, sizeof(NetNumber));
1715cdf0e10cSrcweir
1716cdf0e10cSrcweir return osl_Socket_Ok;
1717cdf0e10cSrcweir }
1718cdf0e10cSrcweir else
1719cdf0e10cSrcweir return osl_Socket_Error;
1720cdf0e10cSrcweir }
1721cdf0e10cSrcweir
1722cdf0e10cSrcweir
1723cdf0e10cSrcweir /*****************************************************************************/
1724cdf0e10cSrcweir /* osl_getIpxNodeNumber */
1725cdf0e10cSrcweir /*****************************************************************************/
1726cdf0e10cSrcweir oslSocketResult SAL_CALL osl_getIpxNodeNumber(oslSocketAddr Addr,
1727cdf0e10cSrcweir oslSocketIpxNodeNumber NodeNumber)
1728cdf0e10cSrcweir
1729cdf0e10cSrcweir {
1730cdf0e10cSrcweir struct sockaddr_ipx* pAddr;
1731cdf0e10cSrcweir
1732cdf0e10cSrcweir pAddr= (struct sockaddr_ipx*)Addr;
1733cdf0e10cSrcweir
1734cdf0e10cSrcweir OSL_ASSERT(pAddr);
1735cdf0e10cSrcweir
1736cdf0e10cSrcweir if (pAddr && (pAddr->sa_family == FAMILY_TO_NATIVE(osl_Socket_FamilyIpx)))
1737cdf0e10cSrcweir {
1738cdf0e10cSrcweir memcpy(NodeNumber, pAddr->sa_nodenum, sizeof(NodeNumber));
1739cdf0e10cSrcweir
1740cdf0e10cSrcweir return osl_Socket_Ok;
1741cdf0e10cSrcweir }
1742cdf0e10cSrcweir else
1743cdf0e10cSrcweir return osl_Socket_Error;
1744cdf0e10cSrcweir }
1745cdf0e10cSrcweir
1746cdf0e10cSrcweir
1747cdf0e10cSrcweir /*****************************************************************************/
1748cdf0e10cSrcweir /* osl_getIpxSocketNumber */
1749cdf0e10cSrcweir /*****************************************************************************/
1750cdf0e10cSrcweir sal_Int32 SAL_CALL osl_getIpxSocketNumber(oslSocketAddr Addr)
1751cdf0e10cSrcweir {
1752cdf0e10cSrcweir struct sockaddr_ipx* pAddr= (struct sockaddr_ipx*)Addr;
1753cdf0e10cSrcweir OSL_ASSERT(pAddr);
1754cdf0e10cSrcweir
1755cdf0e10cSrcweir if (pAddr && (pAddr->sa_family == FAMILY_TO_NATIVE(osl_Socket_FamilyIpx)))
1756cdf0e10cSrcweir return pAddr->sa_socket;
1757cdf0e10cSrcweir else
1758cdf0e10cSrcweir return OSL_INVALID_IPX_SOCKET_NO;
1759cdf0e10cSrcweir }
1760cdf0e10cSrcweir
1761cdf0e10cSrcweir #endif /* OBSOLETE */
1762cdf0e10cSrcweir
1763cdf0e10cSrcweir /*****************************************************************************/
1764cdf0e10cSrcweir /* osl_createSocket */
1765cdf0e10cSrcweir /*****************************************************************************/
osl_createSocket(oslAddrFamily Family,oslSocketType Type,oslProtocol Protocol)1766cdf0e10cSrcweir oslSocket SAL_CALL osl_createSocket(oslAddrFamily Family,
1767cdf0e10cSrcweir oslSocketType Type,
1768cdf0e10cSrcweir oslProtocol Protocol)
1769cdf0e10cSrcweir {
1770cdf0e10cSrcweir int Flags;
1771cdf0e10cSrcweir oslSocket pSocket;
1772cdf0e10cSrcweir
1773cdf0e10cSrcweir /* alloc memory */
1774cdf0e10cSrcweir pSocket= __osl_createSocketImpl(OSL_INVALID_SOCKET);
1775cdf0e10cSrcweir
1776cdf0e10cSrcweir /* create socket */
1777cdf0e10cSrcweir pSocket->m_Socket= socket(FAMILY_TO_NATIVE(Family),
1778cdf0e10cSrcweir TYPE_TO_NATIVE(Type),
1779cdf0e10cSrcweir PROTOCOL_TO_NATIVE(Protocol));
1780cdf0e10cSrcweir
1781cdf0e10cSrcweir /* creation failed => free memory */
1782cdf0e10cSrcweir if(pSocket->m_Socket == OSL_INVALID_SOCKET)
1783cdf0e10cSrcweir {
1784cdf0e10cSrcweir OSL_TRACE("osl_createSocket failed. Errno: %d; %s\n",
1785cdf0e10cSrcweir errno,
1786cdf0e10cSrcweir strerror(errno));
1787cdf0e10cSrcweir
1788cdf0e10cSrcweir __osl_destroySocketImpl((pSocket));
1789cdf0e10cSrcweir pSocket= 0;
1790cdf0e10cSrcweir }
1791cdf0e10cSrcweir else
1792cdf0e10cSrcweir {
1793cdf0e10cSrcweir /* set close-on-exec flag */
1794cdf0e10cSrcweir if ((Flags = fcntl(pSocket->m_Socket, F_GETFD, 0)) != -1)
1795cdf0e10cSrcweir {
1796cdf0e10cSrcweir Flags |= FD_CLOEXEC;
1797cdf0e10cSrcweir if (fcntl(pSocket->m_Socket, F_SETFD, Flags) == -1)
1798cdf0e10cSrcweir {
1799cdf0e10cSrcweir pSocket->m_nLastError=errno;
1800cdf0e10cSrcweir OSL_TRACE("osl_createSocket failed changing socket flags. Errno: %d; %s\n",
1801cdf0e10cSrcweir errno,
1802cdf0e10cSrcweir strerror(errno));
1803cdf0e10cSrcweir }
1804cdf0e10cSrcweir }
1805cdf0e10cSrcweir else
1806cdf0e10cSrcweir {
1807cdf0e10cSrcweir pSocket->m_nLastError=errno;
1808cdf0e10cSrcweir }
1809cdf0e10cSrcweir
1810cdf0e10cSrcweir
1811cdf0e10cSrcweir pSocket->m_CloseCallback = NULL;
1812cdf0e10cSrcweir pSocket->m_CallbackArg = NULL;
1813cdf0e10cSrcweir }
1814cdf0e10cSrcweir
1815cdf0e10cSrcweir return pSocket;
1816cdf0e10cSrcweir }
1817cdf0e10cSrcweir
osl_acquireSocket(oslSocket pSocket)1818cdf0e10cSrcweir void SAL_CALL osl_acquireSocket(oslSocket pSocket)
1819cdf0e10cSrcweir {
1820cdf0e10cSrcweir osl_incrementInterlockedCount( &(pSocket->m_nRefCount ) );
1821cdf0e10cSrcweir }
1822cdf0e10cSrcweir
osl_releaseSocket(oslSocket pSocket)1823cdf0e10cSrcweir void SAL_CALL osl_releaseSocket( oslSocket pSocket )
1824cdf0e10cSrcweir {
1825cdf0e10cSrcweir if( pSocket && 0 == osl_decrementInterlockedCount( &(pSocket->m_nRefCount) ) )
1826cdf0e10cSrcweir {
1827*0d76dfe8SAndrea Pescetti #if CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT
1828cdf0e10cSrcweir if ( pSocket->m_bIsAccepting == sal_True )
1829cdf0e10cSrcweir {
1830cdf0e10cSrcweir OSL_ENSURE(0, "osl_destroySocket : attempt to destroy socket while accepting\n");
1831cdf0e10cSrcweir return;
1832cdf0e10cSrcweir }
1833*0d76dfe8SAndrea Pescetti #endif /* CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT */
1834cdf0e10cSrcweir osl_closeSocket( pSocket );
1835cdf0e10cSrcweir __osl_destroySocketImpl( pSocket );
1836cdf0e10cSrcweir }
1837cdf0e10cSrcweir }
1838cdf0e10cSrcweir
1839cdf0e10cSrcweir
1840cdf0e10cSrcweir
1841cdf0e10cSrcweir /*****************************************************************************/
1842cdf0e10cSrcweir /* osl_closeSocket */
1843cdf0e10cSrcweir /*****************************************************************************/
osl_closeSocket(oslSocket pSocket)1844cdf0e10cSrcweir void SAL_CALL osl_closeSocket(oslSocket pSocket)
1845cdf0e10cSrcweir {
1846cdf0e10cSrcweir int nRet;
1847cdf0e10cSrcweir int nFD;
1848cdf0e10cSrcweir
1849cdf0e10cSrcweir /* socket already invalid */
1850cdf0e10cSrcweir if(pSocket==0)
1851cdf0e10cSrcweir return;
1852cdf0e10cSrcweir
1853cdf0e10cSrcweir pSocket->m_nLastError=0;
1854cdf0e10cSrcweir nFD = pSocket->m_Socket;
1855cdf0e10cSrcweir
1856cdf0e10cSrcweir if (nFD == OSL_INVALID_SOCKET)
1857cdf0e10cSrcweir return;
1858cdf0e10cSrcweir
1859cdf0e10cSrcweir pSocket->m_Socket = OSL_INVALID_SOCKET;
1860cdf0e10cSrcweir
1861*0d76dfe8SAndrea Pescetti #if CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT
1862cdf0e10cSrcweir pSocket->m_bIsInShutdown = sal_True;
1863cdf0e10cSrcweir
1864cdf0e10cSrcweir if ( pSocket->m_bIsAccepting == sal_True )
1865cdf0e10cSrcweir {
1866cdf0e10cSrcweir int nConnFD;
1867cdf0e10cSrcweir union {
1868cdf0e10cSrcweir struct sockaddr aSockAddr;
1869cdf0e10cSrcweir struct sockaddr_in aSockAddrIn;
1870cdf0e10cSrcweir } s;
1871cdf0e10cSrcweir socklen_t nSockLen = sizeof(s.aSockAddr);
1872cdf0e10cSrcweir
1873cdf0e10cSrcweir nRet = getsockname(nFD, &s.aSockAddr, &nSockLen);
1874cdf0e10cSrcweir #if OSL_DEBUG_LEVEL > 1
1875cdf0e10cSrcweir if ( nRet < 0 )
1876cdf0e10cSrcweir {
1877cdf0e10cSrcweir perror("getsockname");
1878cdf0e10cSrcweir }
1879cdf0e10cSrcweir #endif /* OSL_DEBUG_LEVEL */
1880cdf0e10cSrcweir
1881cdf0e10cSrcweir if ( s.aSockAddr.sa_family == AF_INET )
1882cdf0e10cSrcweir {
1883cdf0e10cSrcweir if ( s.aSockAddrIn.sin_addr.s_addr == htonl(INADDR_ANY) )
1884cdf0e10cSrcweir {
1885cdf0e10cSrcweir s.aSockAddrIn.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
1886cdf0e10cSrcweir }
1887cdf0e10cSrcweir
1888cdf0e10cSrcweir nConnFD = socket(AF_INET, SOCK_STREAM, 0);
1889cdf0e10cSrcweir #if OSL_DEBUG_LEVEL > 1
1890cdf0e10cSrcweir if ( nConnFD < 0 )
1891cdf0e10cSrcweir {
1892cdf0e10cSrcweir perror("socket");
1893cdf0e10cSrcweir }
1894cdf0e10cSrcweir #endif /* OSL_DEBUG_LEVEL */
1895cdf0e10cSrcweir
1896cdf0e10cSrcweir nRet = connect(nConnFD, &s.aSockAddr, sizeof(s.aSockAddr));
1897cdf0e10cSrcweir #if OSL_DEBUG_LEVEL > 1
1898cdf0e10cSrcweir if ( nRet < 0 )
1899cdf0e10cSrcweir {
1900cdf0e10cSrcweir perror("connect");
1901cdf0e10cSrcweir }
1902cdf0e10cSrcweir #endif /* OSL_DEBUG_LEVEL */
1903cdf0e10cSrcweir close(nConnFD);
1904cdf0e10cSrcweir }
1905cdf0e10cSrcweir pSocket->m_bIsAccepting = sal_False;
1906cdf0e10cSrcweir }
1907*0d76dfe8SAndrea Pescetti #endif /* CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT */
1908cdf0e10cSrcweir
1909cdf0e10cSrcweir /* registrierten Callback ausfuehren */
1910cdf0e10cSrcweir if (pSocket->m_CloseCallback != NULL)
1911cdf0e10cSrcweir {
1912cdf0e10cSrcweir pSocket->m_CloseCallback(pSocket->m_CallbackArg);
1913cdf0e10cSrcweir }
1914cdf0e10cSrcweir
1915cdf0e10cSrcweir nRet=close(nFD);
1916cdf0e10cSrcweir if ( nRet != 0 )
1917cdf0e10cSrcweir {
1918cdf0e10cSrcweir pSocket->m_nLastError=errno;
1919cdf0e10cSrcweir OSL_TRACE("closeSocket close error '%s'\n",strerror(errno));
1920cdf0e10cSrcweir }
1921cdf0e10cSrcweir
1922cdf0e10cSrcweir pSocket->m_Socket = OSL_INVALID_SOCKET;
1923cdf0e10cSrcweir }
1924cdf0e10cSrcweir
1925cdf0e10cSrcweir /*****************************************************************************/
1926cdf0e10cSrcweir /* osl_getLocalAddrOfSocket */
1927cdf0e10cSrcweir /* Note that I rely on the fact that oslSocketAddr and struct sockaddr */
1928cdf0e10cSrcweir /* are the same! I don't like it very much but see no other easy way to conceal */
1929cdf0e10cSrcweir /* the struct sockaddr from the eyes of the user. */
1930cdf0e10cSrcweir /*****************************************************************************/
osl_getLocalAddrOfSocket(oslSocket pSocket)1931cdf0e10cSrcweir oslSocketAddr SAL_CALL osl_getLocalAddrOfSocket(oslSocket pSocket)
1932cdf0e10cSrcweir {
1933cdf0e10cSrcweir socklen_t AddrLen;
1934cdf0e10cSrcweir struct sockaddr Addr;
1935cdf0e10cSrcweir oslSocketAddr pAddr;
1936cdf0e10cSrcweir
1937cdf0e10cSrcweir if (pSocket == NULL) /* ENOTSOCK */
1938cdf0e10cSrcweir return ((oslSocketAddr)NULL);
1939cdf0e10cSrcweir
1940cdf0e10cSrcweir AddrLen= sizeof(struct sockaddr);
1941cdf0e10cSrcweir
1942cdf0e10cSrcweir if (getsockname(pSocket->m_Socket, &Addr, &AddrLen) == OSL_SOCKET_ERROR)
1943cdf0e10cSrcweir return ((oslSocketAddr)NULL);
1944cdf0e10cSrcweir
1945cdf0e10cSrcweir pAddr = __osl_createSocketAddrFromSystem( &Addr );
1946cdf0e10cSrcweir return pAddr;
1947cdf0e10cSrcweir }
1948cdf0e10cSrcweir
1949cdf0e10cSrcweir /*****************************************************************************/
1950cdf0e10cSrcweir /* osl_getPeerAddrOfSocket */
1951cdf0e10cSrcweir /*****************************************************************************/
osl_getPeerAddrOfSocket(oslSocket pSocket)1952cdf0e10cSrcweir oslSocketAddr SAL_CALL osl_getPeerAddrOfSocket(oslSocket pSocket)
1953cdf0e10cSrcweir {
1954cdf0e10cSrcweir socklen_t AddrLen;
1955cdf0e10cSrcweir struct sockaddr Addr;
1956cdf0e10cSrcweir
1957cdf0e10cSrcweir OSL_ASSERT(pSocket);
1958cdf0e10cSrcweir if ( pSocket == 0 )
1959cdf0e10cSrcweir {
1960cdf0e10cSrcweir return 0;
1961cdf0e10cSrcweir }
1962cdf0e10cSrcweir
1963cdf0e10cSrcweir pSocket->m_nLastError=0;
1964cdf0e10cSrcweir AddrLen= sizeof(struct sockaddr);
1965cdf0e10cSrcweir
1966cdf0e10cSrcweir if(getpeername(pSocket->m_Socket, &Addr, &AddrLen) == OSL_SOCKET_ERROR)
1967cdf0e10cSrcweir {
1968cdf0e10cSrcweir pSocket->m_nLastError=errno;
1969cdf0e10cSrcweir return 0;
1970cdf0e10cSrcweir }
1971cdf0e10cSrcweir return __osl_createSocketAddrFromSystem( &Addr );
1972cdf0e10cSrcweir }
1973cdf0e10cSrcweir
1974cdf0e10cSrcweir /*****************************************************************************/
1975cdf0e10cSrcweir /* osl_bindAddrToSocket */
1976cdf0e10cSrcweir /*****************************************************************************/
osl_bindAddrToSocket(oslSocket pSocket,oslSocketAddr pAddr)1977cdf0e10cSrcweir sal_Bool SAL_CALL osl_bindAddrToSocket(oslSocket pSocket,
1978cdf0e10cSrcweir oslSocketAddr pAddr)
1979cdf0e10cSrcweir {
1980cdf0e10cSrcweir int nRet;
1981cdf0e10cSrcweir
1982cdf0e10cSrcweir OSL_ASSERT(pSocket && pAddr );
1983cdf0e10cSrcweir if ( pSocket == 0 || pAddr == 0 )
1984cdf0e10cSrcweir {
1985cdf0e10cSrcweir return sal_False;
1986cdf0e10cSrcweir }
1987cdf0e10cSrcweir
1988cdf0e10cSrcweir pSocket->m_nLastError=0;
1989cdf0e10cSrcweir
1990cdf0e10cSrcweir nRet = bind(pSocket->m_Socket, &(pAddr->m_sockaddr), sizeof(struct sockaddr));
1991cdf0e10cSrcweir
1992cdf0e10cSrcweir if ( nRet == OSL_SOCKET_ERROR)
1993cdf0e10cSrcweir {
1994cdf0e10cSrcweir pSocket->m_nLastError=errno;
1995cdf0e10cSrcweir return sal_False;
1996cdf0e10cSrcweir }
1997cdf0e10cSrcweir
1998cdf0e10cSrcweir return sal_True;
1999cdf0e10cSrcweir }
2000cdf0e10cSrcweir
2001cdf0e10cSrcweir
2002cdf0e10cSrcweir /*****************************************************************************/
2003cdf0e10cSrcweir /* osl_listenOnSocket */
2004cdf0e10cSrcweir /*****************************************************************************/
osl_listenOnSocket(oslSocket pSocket,sal_Int32 MaxPendingConnections)2005cdf0e10cSrcweir sal_Bool SAL_CALL osl_listenOnSocket(oslSocket pSocket,
2006cdf0e10cSrcweir sal_Int32 MaxPendingConnections)
2007cdf0e10cSrcweir {
2008cdf0e10cSrcweir int nRet;
2009cdf0e10cSrcweir
2010cdf0e10cSrcweir OSL_ASSERT(pSocket);
2011cdf0e10cSrcweir if ( pSocket == 0 )
2012cdf0e10cSrcweir {
2013cdf0e10cSrcweir return sal_False;
2014cdf0e10cSrcweir }
2015cdf0e10cSrcweir
2016cdf0e10cSrcweir pSocket->m_nLastError=0;
2017cdf0e10cSrcweir
2018cdf0e10cSrcweir nRet = listen(pSocket->m_Socket,
2019cdf0e10cSrcweir MaxPendingConnections == -1 ?
2020cdf0e10cSrcweir SOMAXCONN :
2021cdf0e10cSrcweir MaxPendingConnections);
2022cdf0e10cSrcweir if ( nRet == OSL_SOCKET_ERROR)
2023cdf0e10cSrcweir {
2024cdf0e10cSrcweir pSocket->m_nLastError=errno;
2025cdf0e10cSrcweir return sal_False;
2026cdf0e10cSrcweir }
2027cdf0e10cSrcweir
2028cdf0e10cSrcweir return sal_True;
2029cdf0e10cSrcweir }
2030cdf0e10cSrcweir
2031cdf0e10cSrcweir
2032cdf0e10cSrcweir /*****************************************************************************/
2033cdf0e10cSrcweir /* osl_connectSocketTo */
2034cdf0e10cSrcweir /*****************************************************************************/
osl_connectSocketTo(oslSocket pSocket,oslSocketAddr pAddr,const TimeValue * pTimeout)2035cdf0e10cSrcweir oslSocketResult SAL_CALL osl_connectSocketTo(oslSocket pSocket,
2036cdf0e10cSrcweir oslSocketAddr pAddr,
2037cdf0e10cSrcweir const TimeValue* pTimeout)
2038cdf0e10cSrcweir {
2039cdf0e10cSrcweir fd_set WriteSet;
2040cdf0e10cSrcweir fd_set ExcptSet;
2041cdf0e10cSrcweir int ReadyHandles;
2042cdf0e10cSrcweir struct timeval tv;
2043cdf0e10cSrcweir oslSocketResult Result= osl_Socket_Ok;
2044cdf0e10cSrcweir
2045cdf0e10cSrcweir OSL_PRECOND(pSocket, "osl_connectSocketTo(): need a valid socket!\n");
2046cdf0e10cSrcweir
2047cdf0e10cSrcweir if ( pSocket == 0 )
2048cdf0e10cSrcweir {
2049cdf0e10cSrcweir return osl_Socket_Error;
2050cdf0e10cSrcweir }
2051cdf0e10cSrcweir
2052cdf0e10cSrcweir pSocket->m_nLastError=0;
2053cdf0e10cSrcweir
2054cdf0e10cSrcweir if (osl_isNonBlockingMode(pSocket))
2055cdf0e10cSrcweir {
2056cdf0e10cSrcweir if (connect(pSocket->m_Socket,
2057cdf0e10cSrcweir &(pAddr->m_sockaddr),
2058cdf0e10cSrcweir sizeof(struct sockaddr)) != OSL_SOCKET_ERROR)
2059cdf0e10cSrcweir return osl_Socket_Ok;
2060cdf0e10cSrcweir else
2061cdf0e10cSrcweir if (errno == EWOULDBLOCK || errno == EINPROGRESS)
2062cdf0e10cSrcweir {
2063cdf0e10cSrcweir pSocket->m_nLastError=EINPROGRESS;
2064cdf0e10cSrcweir return osl_Socket_InProgress;
2065cdf0e10cSrcweir }
2066cdf0e10cSrcweir
2067cdf0e10cSrcweir
2068cdf0e10cSrcweir pSocket->m_nLastError=errno;
2069cdf0e10cSrcweir OSL_TRACE("can't connect : '%s'",strerror(errno));
2070cdf0e10cSrcweir return osl_Socket_Error;
2071cdf0e10cSrcweir }
2072cdf0e10cSrcweir
2073cdf0e10cSrcweir /* set socket temporarily to non-blocking */
2074cdf0e10cSrcweir OSL_VERIFY(osl_enableNonBlockingMode(pSocket, sal_True));
2075cdf0e10cSrcweir
2076cdf0e10cSrcweir /* initiate connect */
2077cdf0e10cSrcweir if(connect(pSocket->m_Socket,
2078cdf0e10cSrcweir &(pAddr->m_sockaddr),
2079cdf0e10cSrcweir sizeof(struct sockaddr)) != OSL_SOCKET_ERROR)
2080cdf0e10cSrcweir {
2081cdf0e10cSrcweir /* immediate connection */
2082cdf0e10cSrcweir osl_enableNonBlockingMode(pSocket, sal_False);
2083cdf0e10cSrcweir
2084cdf0e10cSrcweir return osl_Socket_Ok;
2085cdf0e10cSrcweir }
2086cdf0e10cSrcweir else
2087cdf0e10cSrcweir {
2088cdf0e10cSrcweir /* really an error or just delayed? */
2089cdf0e10cSrcweir if (errno != EINPROGRESS)
2090cdf0e10cSrcweir {
2091cdf0e10cSrcweir pSocket->m_nLastError=errno;
2092cdf0e10cSrcweir OSL_TRACE(
2093cdf0e10cSrcweir "osl_connectSocketTo(): connect failed: errno: %d (%s)\n",
2094cdf0e10cSrcweir errno, strerror(errno));
2095cdf0e10cSrcweir
2096cdf0e10cSrcweir osl_enableNonBlockingMode(pSocket, sal_False);
2097cdf0e10cSrcweir return osl_Socket_Error;
2098cdf0e10cSrcweir }
2099cdf0e10cSrcweir }
2100cdf0e10cSrcweir
2101cdf0e10cSrcweir
2102cdf0e10cSrcweir /* prepare select set for socket */
2103cdf0e10cSrcweir FD_ZERO(&WriteSet);
2104cdf0e10cSrcweir FD_ZERO(&ExcptSet);
2105cdf0e10cSrcweir FD_SET(pSocket->m_Socket, &WriteSet);
2106cdf0e10cSrcweir FD_SET(pSocket->m_Socket, &ExcptSet);
2107cdf0e10cSrcweir
2108cdf0e10cSrcweir /* prepare timeout */
2109cdf0e10cSrcweir if (pTimeout)
2110cdf0e10cSrcweir {
2111cdf0e10cSrcweir /* divide milliseconds into seconds and microseconds */
2112cdf0e10cSrcweir tv.tv_sec= pTimeout->Seconds;
2113cdf0e10cSrcweir tv.tv_usec= pTimeout->Nanosec / 1000L;
2114cdf0e10cSrcweir }
2115cdf0e10cSrcweir
2116cdf0e10cSrcweir /* select */
2117cdf0e10cSrcweir ReadyHandles= select(pSocket->m_Socket+1,
2118cdf0e10cSrcweir 0,
2119cdf0e10cSrcweir PTR_FD_SET(WriteSet),
2120cdf0e10cSrcweir PTR_FD_SET(ExcptSet),
2121cdf0e10cSrcweir (pTimeout) ? &tv : 0);
2122cdf0e10cSrcweir
2123cdf0e10cSrcweir if (ReadyHandles > 0) /* connected */
2124cdf0e10cSrcweir {
2125cdf0e10cSrcweir if ( FD_ISSET(pSocket->m_Socket, &WriteSet ) )
2126cdf0e10cSrcweir {
2127cdf0e10cSrcweir int nErrorCode = 0;
2128cdf0e10cSrcweir socklen_t nErrorSize = sizeof( nErrorCode );
2129cdf0e10cSrcweir
2130cdf0e10cSrcweir int nSockOpt;
2131cdf0e10cSrcweir
2132cdf0e10cSrcweir nSockOpt = getsockopt ( pSocket->m_Socket, SOL_SOCKET, SO_ERROR,
2133cdf0e10cSrcweir &nErrorCode, &nErrorSize );
2134cdf0e10cSrcweir if ( (nSockOpt == 0) && (nErrorCode == 0))
2135cdf0e10cSrcweir Result = osl_Socket_Ok;
2136cdf0e10cSrcweir else
2137cdf0e10cSrcweir Result = osl_Socket_Error;
2138cdf0e10cSrcweir }
2139cdf0e10cSrcweir else
2140cdf0e10cSrcweir {
2141cdf0e10cSrcweir Result= osl_Socket_Error;
2142cdf0e10cSrcweir }
2143cdf0e10cSrcweir }
2144cdf0e10cSrcweir else if (ReadyHandles < 0) /* error */
2145cdf0e10cSrcweir {
2146cdf0e10cSrcweir if (errno == EBADF) /* most probably interrupted by close() */
2147cdf0e10cSrcweir {
2148cdf0e10cSrcweir /* do not access pSockImpl because it is about to be or */
2149cdf0e10cSrcweir /* already destroyed */
2150cdf0e10cSrcweir return osl_Socket_Interrupted;
2151cdf0e10cSrcweir }
2152cdf0e10cSrcweir else
2153cdf0e10cSrcweir {
2154cdf0e10cSrcweir pSocket->m_nLastError=errno;
2155cdf0e10cSrcweir Result= osl_Socket_Error;
2156cdf0e10cSrcweir }
2157cdf0e10cSrcweir }
2158cdf0e10cSrcweir else /* timeout */
2159cdf0e10cSrcweir {
2160cdf0e10cSrcweir pSocket->m_nLastError=errno;
2161cdf0e10cSrcweir Result= osl_Socket_TimedOut;
2162cdf0e10cSrcweir }
2163cdf0e10cSrcweir
2164cdf0e10cSrcweir osl_enableNonBlockingMode(pSocket, sal_False);
2165cdf0e10cSrcweir
2166cdf0e10cSrcweir return Result;
2167cdf0e10cSrcweir }
2168cdf0e10cSrcweir
2169cdf0e10cSrcweir
2170cdf0e10cSrcweir /*****************************************************************************/
2171cdf0e10cSrcweir /* osl_acceptConnectionOnSocket */
2172cdf0e10cSrcweir /*****************************************************************************/
osl_acceptConnectionOnSocket(oslSocket pSocket,oslSocketAddr * ppAddr)2173cdf0e10cSrcweir oslSocket SAL_CALL osl_acceptConnectionOnSocket(oslSocket pSocket,
2174cdf0e10cSrcweir oslSocketAddr* ppAddr)
2175cdf0e10cSrcweir {
2176cdf0e10cSrcweir struct sockaddr Addr;
2177cdf0e10cSrcweir int Connection, Flags;
2178cdf0e10cSrcweir oslSocket pConnectionSockImpl;
2179cdf0e10cSrcweir
2180cdf0e10cSrcweir socklen_t AddrLen = sizeof(struct sockaddr);
2181cdf0e10cSrcweir OSL_ASSERT(pSocket);
2182cdf0e10cSrcweir if ( pSocket == 0 )
2183cdf0e10cSrcweir {
2184cdf0e10cSrcweir return 0;
2185cdf0e10cSrcweir }
2186cdf0e10cSrcweir
2187cdf0e10cSrcweir pSocket->m_nLastError=0;
2188*0d76dfe8SAndrea Pescetti #if CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT
2189cdf0e10cSrcweir pSocket->m_bIsAccepting = sal_True;
2190*0d76dfe8SAndrea Pescetti #endif /* CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT */
2191cdf0e10cSrcweir
2192cdf0e10cSrcweir if( ppAddr && *ppAddr )
2193cdf0e10cSrcweir {
2194cdf0e10cSrcweir osl_destroySocketAddr( *ppAddr );
2195cdf0e10cSrcweir *ppAddr = 0;
2196cdf0e10cSrcweir }
2197cdf0e10cSrcweir
2198cdf0e10cSrcweir /* prevent Linux EINTR behaviour */
2199cdf0e10cSrcweir do
2200cdf0e10cSrcweir {
2201cdf0e10cSrcweir Connection = accept(pSocket->m_Socket, &Addr, &AddrLen);
2202cdf0e10cSrcweir } while (Connection == -1 && errno == EINTR);
2203cdf0e10cSrcweir
2204cdf0e10cSrcweir
2205cdf0e10cSrcweir /* accept failed? */
2206cdf0e10cSrcweir if( Connection == OSL_SOCKET_ERROR )
2207cdf0e10cSrcweir {
2208cdf0e10cSrcweir pSocket->m_nLastError=errno;
2209cdf0e10cSrcweir OSL_TRACE("osl_acceptConnectionOnSocket : accept error '%s'\n",strerror(errno));
2210cdf0e10cSrcweir
2211*0d76dfe8SAndrea Pescetti #if CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT
2212cdf0e10cSrcweir pSocket->m_bIsAccepting = sal_False;
2213*0d76dfe8SAndrea Pescetti #endif /* CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT */
2214cdf0e10cSrcweir return 0;
2215cdf0e10cSrcweir }
2216cdf0e10cSrcweir
2217cdf0e10cSrcweir OSL_ASSERT(AddrLen == sizeof(struct sockaddr));
2218cdf0e10cSrcweir
2219cdf0e10cSrcweir
2220*0d76dfe8SAndrea Pescetti #if CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT
2221cdf0e10cSrcweir if ( pSocket->m_bIsInShutdown == sal_True )
2222cdf0e10cSrcweir {
2223cdf0e10cSrcweir close(Connection);
2224cdf0e10cSrcweir OSL_TRACE("osl_acceptConnectionOnSocket : close while accept\n");
2225cdf0e10cSrcweir return 0;
2226cdf0e10cSrcweir }
2227*0d76dfe8SAndrea Pescetti #endif /* CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT */
2228cdf0e10cSrcweir
2229cdf0e10cSrcweir
2230cdf0e10cSrcweir if(ppAddr)
2231cdf0e10cSrcweir {
2232cdf0e10cSrcweir *ppAddr= __osl_createSocketAddrFromSystem(&Addr);
2233cdf0e10cSrcweir }
2234cdf0e10cSrcweir
2235cdf0e10cSrcweir /* alloc memory */
2236cdf0e10cSrcweir pConnectionSockImpl= __osl_createSocketImpl(OSL_INVALID_SOCKET);
2237cdf0e10cSrcweir
2238cdf0e10cSrcweir /* set close-on-exec flag */
2239cdf0e10cSrcweir if ((Flags = fcntl(Connection, F_GETFD, 0)) != -1)
2240cdf0e10cSrcweir {
2241cdf0e10cSrcweir Flags |= FD_CLOEXEC;
2242cdf0e10cSrcweir if (fcntl(Connection, F_SETFD, Flags) == -1)
2243cdf0e10cSrcweir {
2244cdf0e10cSrcweir pSocket->m_nLastError=errno;
2245cdf0e10cSrcweir OSL_TRACE("osl_acceptConnectionOnSocket failed changing socket flags. Errno: %d (%s)\n",
2246cdf0e10cSrcweir errno,
2247cdf0e10cSrcweir strerror(errno));
2248cdf0e10cSrcweir }
2249cdf0e10cSrcweir
2250cdf0e10cSrcweir }
2251cdf0e10cSrcweir
2252cdf0e10cSrcweir pConnectionSockImpl->m_Socket = Connection;
2253cdf0e10cSrcweir pConnectionSockImpl->m_nLastError = 0;
2254cdf0e10cSrcweir pConnectionSockImpl->m_CloseCallback = NULL;
2255cdf0e10cSrcweir pConnectionSockImpl->m_CallbackArg = NULL;
2256*0d76dfe8SAndrea Pescetti #if CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT
2257cdf0e10cSrcweir pConnectionSockImpl->m_bIsAccepting = sal_False;
2258cdf0e10cSrcweir
2259cdf0e10cSrcweir pSocket->m_bIsAccepting = sal_False;
2260*0d76dfe8SAndrea Pescetti #endif /* CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT */
2261cdf0e10cSrcweir return pConnectionSockImpl;
2262cdf0e10cSrcweir }
2263cdf0e10cSrcweir
2264cdf0e10cSrcweir /*****************************************************************************/
2265cdf0e10cSrcweir /* osl_receiveSocket */
2266cdf0e10cSrcweir /*****************************************************************************/
osl_receiveSocket(oslSocket pSocket,void * pBuffer,sal_uInt32 BytesToRead,oslSocketMsgFlag Flag)2267cdf0e10cSrcweir sal_Int32 SAL_CALL osl_receiveSocket(oslSocket pSocket,
2268cdf0e10cSrcweir void* pBuffer,
2269cdf0e10cSrcweir sal_uInt32 BytesToRead,
2270cdf0e10cSrcweir oslSocketMsgFlag Flag)
2271cdf0e10cSrcweir {
2272cdf0e10cSrcweir int nRead;
2273cdf0e10cSrcweir
2274cdf0e10cSrcweir OSL_ASSERT(pSocket);
2275cdf0e10cSrcweir if ( pSocket == 0 )
2276cdf0e10cSrcweir {
2277cdf0e10cSrcweir OSL_TRACE("osl_receiveSocket : Invalid socket");
2278cdf0e10cSrcweir return -1;
2279cdf0e10cSrcweir }
2280cdf0e10cSrcweir
2281cdf0e10cSrcweir pSocket->m_nLastError=0;
2282cdf0e10cSrcweir
2283cdf0e10cSrcweir do
2284cdf0e10cSrcweir {
2285cdf0e10cSrcweir nRead = recv(pSocket->m_Socket,
2286cdf0e10cSrcweir (sal_Char*)pBuffer,
2287cdf0e10cSrcweir BytesToRead,
2288cdf0e10cSrcweir MSG_FLAG_TO_NATIVE(Flag));
2289cdf0e10cSrcweir } while ( nRead < 0 && errno == EINTR );
2290cdf0e10cSrcweir
2291cdf0e10cSrcweir if ( nRead < 0 )
2292cdf0e10cSrcweir {
2293cdf0e10cSrcweir pSocket->m_nLastError=errno;
2294cdf0e10cSrcweir OSL_TRACE("osl_receiveSocket failed : %i '%s'",nRead,strerror(errno));
2295cdf0e10cSrcweir }
2296cdf0e10cSrcweir else if ( nRead == 0 )
2297cdf0e10cSrcweir {
2298cdf0e10cSrcweir OSL_TRACE("osl_receiveSocket failed : %i '%s'",nRead,"EOL");
2299cdf0e10cSrcweir }
2300cdf0e10cSrcweir
2301cdf0e10cSrcweir return nRead;
2302cdf0e10cSrcweir }
2303cdf0e10cSrcweir
2304cdf0e10cSrcweir
2305cdf0e10cSrcweir /*****************************************************************************/
2306cdf0e10cSrcweir /* osl_receiveFromSocket */
2307cdf0e10cSrcweir /*****************************************************************************/
osl_receiveFromSocket(oslSocket pSocket,oslSocketAddr pSenderAddr,void * pBuffer,sal_uInt32 BufferSize,oslSocketMsgFlag Flag)2308cdf0e10cSrcweir sal_Int32 SAL_CALL osl_receiveFromSocket(oslSocket pSocket,
2309cdf0e10cSrcweir oslSocketAddr pSenderAddr,
2310cdf0e10cSrcweir void* pBuffer,
2311cdf0e10cSrcweir sal_uInt32 BufferSize,
2312cdf0e10cSrcweir oslSocketMsgFlag Flag)
2313cdf0e10cSrcweir {
2314cdf0e10cSrcweir int nRead;
2315cdf0e10cSrcweir struct sockaddr *pSystemSockAddr = 0;
2316cdf0e10cSrcweir socklen_t AddrLen = 0;
2317cdf0e10cSrcweir if( pSenderAddr )
2318cdf0e10cSrcweir {
2319cdf0e10cSrcweir AddrLen = sizeof( struct sockaddr );
2320cdf0e10cSrcweir pSystemSockAddr = &(pSenderAddr->m_sockaddr);
2321cdf0e10cSrcweir }
2322cdf0e10cSrcweir
2323cdf0e10cSrcweir OSL_ASSERT(pSocket);
2324cdf0e10cSrcweir if ( pSocket == 0 )
2325cdf0e10cSrcweir {
2326cdf0e10cSrcweir OSL_TRACE("osl_receiveFromSocket : Invalid socket");
2327cdf0e10cSrcweir return -1;
2328cdf0e10cSrcweir }
2329cdf0e10cSrcweir
2330cdf0e10cSrcweir pSocket->m_nLastError=0;
2331cdf0e10cSrcweir
2332cdf0e10cSrcweir nRead = recvfrom(pSocket->m_Socket,
2333cdf0e10cSrcweir (sal_Char*)pBuffer,
2334cdf0e10cSrcweir BufferSize,
2335cdf0e10cSrcweir MSG_FLAG_TO_NATIVE(Flag),
2336cdf0e10cSrcweir pSystemSockAddr,
2337cdf0e10cSrcweir &AddrLen);
2338cdf0e10cSrcweir
2339cdf0e10cSrcweir if ( nRead < 0 )
2340cdf0e10cSrcweir {
2341cdf0e10cSrcweir pSocket->m_nLastError=errno;
2342cdf0e10cSrcweir OSL_TRACE("osl_receiveFromSocket failed : %i '%s'",nRead,strerror(errno));
2343cdf0e10cSrcweir }
2344cdf0e10cSrcweir else if ( nRead == 0 )
2345cdf0e10cSrcweir {
2346cdf0e10cSrcweir OSL_TRACE("osl_receiveSocket failed : %i '%s'",nRead,"EOL");
2347cdf0e10cSrcweir }
2348cdf0e10cSrcweir
2349cdf0e10cSrcweir return nRead;
2350cdf0e10cSrcweir }
2351cdf0e10cSrcweir
2352cdf0e10cSrcweir
2353cdf0e10cSrcweir /*****************************************************************************/
2354cdf0e10cSrcweir /* osl_sendSocket */
2355cdf0e10cSrcweir /*****************************************************************************/
osl_sendSocket(oslSocket pSocket,const void * pBuffer,sal_uInt32 BytesToSend,oslSocketMsgFlag Flag)2356cdf0e10cSrcweir sal_Int32 SAL_CALL osl_sendSocket(oslSocket pSocket,
2357cdf0e10cSrcweir const void* pBuffer,
2358cdf0e10cSrcweir sal_uInt32 BytesToSend,
2359cdf0e10cSrcweir oslSocketMsgFlag Flag)
2360cdf0e10cSrcweir {
2361cdf0e10cSrcweir int nWritten;
2362cdf0e10cSrcweir
2363cdf0e10cSrcweir OSL_ASSERT(pSocket);
2364cdf0e10cSrcweir if ( pSocket == 0 )
2365cdf0e10cSrcweir {
2366cdf0e10cSrcweir OSL_TRACE("osl_sendSocket : Invalid socket");
2367cdf0e10cSrcweir return -1;
2368cdf0e10cSrcweir }
2369cdf0e10cSrcweir
2370cdf0e10cSrcweir pSocket->m_nLastError=0;
2371cdf0e10cSrcweir
2372cdf0e10cSrcweir do
2373cdf0e10cSrcweir {
2374cdf0e10cSrcweir nWritten = send(pSocket->m_Socket,
2375cdf0e10cSrcweir (sal_Char*)pBuffer,
2376cdf0e10cSrcweir BytesToSend,
2377cdf0e10cSrcweir MSG_FLAG_TO_NATIVE(Flag));
2378cdf0e10cSrcweir } while ( nWritten < 0 && errno == EINTR );
2379cdf0e10cSrcweir
2380cdf0e10cSrcweir
2381cdf0e10cSrcweir if ( nWritten < 0 )
2382cdf0e10cSrcweir {
2383cdf0e10cSrcweir pSocket->m_nLastError=errno;
2384cdf0e10cSrcweir OSL_TRACE("osl_sendSocket failed : %i '%s'",nWritten,strerror(errno));
2385cdf0e10cSrcweir }
2386cdf0e10cSrcweir else if ( nWritten == 0 )
2387cdf0e10cSrcweir {
2388cdf0e10cSrcweir OSL_TRACE("osl_sendSocket failed : %i '%s'",nWritten,"EOL");
2389cdf0e10cSrcweir }
2390cdf0e10cSrcweir
2391cdf0e10cSrcweir return nWritten;
2392cdf0e10cSrcweir }
2393cdf0e10cSrcweir
2394cdf0e10cSrcweir /*****************************************************************************/
2395cdf0e10cSrcweir /* osl_sendToSocket */
2396cdf0e10cSrcweir /*****************************************************************************/
osl_sendToSocket(oslSocket pSocket,oslSocketAddr ReceiverAddr,const void * pBuffer,sal_uInt32 BytesToSend,oslSocketMsgFlag Flag)2397cdf0e10cSrcweir sal_Int32 SAL_CALL osl_sendToSocket(oslSocket pSocket,
2398cdf0e10cSrcweir oslSocketAddr ReceiverAddr,
2399cdf0e10cSrcweir const void* pBuffer,
2400cdf0e10cSrcweir sal_uInt32 BytesToSend,
2401cdf0e10cSrcweir oslSocketMsgFlag Flag)
2402cdf0e10cSrcweir {
2403cdf0e10cSrcweir int nWritten;
2404cdf0e10cSrcweir
2405cdf0e10cSrcweir struct sockaddr *pSystemSockAddr = 0;
2406cdf0e10cSrcweir int AddrLen = 0;
2407cdf0e10cSrcweir if( ReceiverAddr )
2408cdf0e10cSrcweir {
2409cdf0e10cSrcweir pSystemSockAddr = &(ReceiverAddr->m_sockaddr);
2410cdf0e10cSrcweir AddrLen = sizeof( struct sockaddr );
2411cdf0e10cSrcweir }
2412cdf0e10cSrcweir
2413cdf0e10cSrcweir OSL_ASSERT(pSocket);
2414cdf0e10cSrcweir if ( pSocket == 0 )
2415cdf0e10cSrcweir {
2416cdf0e10cSrcweir OSL_TRACE("osl_sendToSocket : Invalid socket");
2417cdf0e10cSrcweir return -1;
2418cdf0e10cSrcweir }
2419cdf0e10cSrcweir
2420cdf0e10cSrcweir pSocket->m_nLastError=0;
2421cdf0e10cSrcweir
2422cdf0e10cSrcweir /* ReceiverAddr might be 0 when used on a connected socket. */
2423cdf0e10cSrcweir /* Then sendto should behave like send. */
2424cdf0e10cSrcweir
2425cdf0e10cSrcweir nWritten = sendto(pSocket->m_Socket,
2426cdf0e10cSrcweir (sal_Char*)pBuffer,
2427cdf0e10cSrcweir BytesToSend,
2428cdf0e10cSrcweir MSG_FLAG_TO_NATIVE(Flag),
2429cdf0e10cSrcweir pSystemSockAddr,
2430cdf0e10cSrcweir AddrLen);
2431cdf0e10cSrcweir
2432cdf0e10cSrcweir if ( nWritten < 0 )
2433cdf0e10cSrcweir {
2434cdf0e10cSrcweir pSocket->m_nLastError=errno;
2435cdf0e10cSrcweir OSL_TRACE("osl_sendToSocket failed : %i '%s'",nWritten,strerror(errno));
2436cdf0e10cSrcweir }
2437cdf0e10cSrcweir else if ( nWritten == 0 )
2438cdf0e10cSrcweir {
2439cdf0e10cSrcweir OSL_TRACE("osl_sendToSocket failed : %i '%s'",nWritten,"EOL");
2440cdf0e10cSrcweir }
2441cdf0e10cSrcweir
2442cdf0e10cSrcweir return nWritten;
2443cdf0e10cSrcweir }
2444cdf0e10cSrcweir
2445cdf0e10cSrcweir /*****************************************************************************/
2446cdf0e10cSrcweir /* osl_readSocket */
2447cdf0e10cSrcweir /*****************************************************************************/
osl_readSocket(oslSocket pSocket,void * pBuffer,sal_Int32 n)2448cdf0e10cSrcweir sal_Int32 SAL_CALL osl_readSocket (
2449cdf0e10cSrcweir oslSocket pSocket, void *pBuffer, sal_Int32 n )
2450cdf0e10cSrcweir {
2451cdf0e10cSrcweir sal_uInt8 * Ptr = (sal_uInt8 *)pBuffer;
2452cdf0e10cSrcweir sal_uInt32 BytesRead= 0;
2453cdf0e10cSrcweir sal_uInt32 BytesToRead= n;
2454cdf0e10cSrcweir
2455cdf0e10cSrcweir OSL_ASSERT( pSocket);
2456cdf0e10cSrcweir
2457cdf0e10cSrcweir /* loop until all desired bytes were read or an error occured */
2458cdf0e10cSrcweir while (BytesToRead > 0)
2459cdf0e10cSrcweir {
2460cdf0e10cSrcweir sal_Int32 RetVal;
2461cdf0e10cSrcweir RetVal= osl_receiveSocket(pSocket,
2462cdf0e10cSrcweir Ptr,
2463cdf0e10cSrcweir BytesToRead,
2464cdf0e10cSrcweir osl_Socket_MsgNormal);
2465cdf0e10cSrcweir
2466cdf0e10cSrcweir /* error occured? */
2467cdf0e10cSrcweir if(RetVal <= 0)
2468cdf0e10cSrcweir {
2469cdf0e10cSrcweir break;
2470cdf0e10cSrcweir }
2471cdf0e10cSrcweir
2472cdf0e10cSrcweir BytesToRead -= RetVal;
2473cdf0e10cSrcweir BytesRead += RetVal;
2474cdf0e10cSrcweir Ptr += RetVal;
2475cdf0e10cSrcweir }
2476cdf0e10cSrcweir
2477cdf0e10cSrcweir return BytesRead;
2478cdf0e10cSrcweir }
2479cdf0e10cSrcweir
2480cdf0e10cSrcweir /*****************************************************************************/
2481cdf0e10cSrcweir /* osl_writeSocket */
2482cdf0e10cSrcweir /*****************************************************************************/
osl_writeSocket(oslSocket pSocket,const void * pBuffer,sal_Int32 n)2483cdf0e10cSrcweir sal_Int32 SAL_CALL osl_writeSocket(
2484cdf0e10cSrcweir oslSocket pSocket, const void *pBuffer, sal_Int32 n )
2485cdf0e10cSrcweir {
2486cdf0e10cSrcweir /* loop until all desired bytes were send or an error occured */
2487cdf0e10cSrcweir sal_uInt32 BytesSend= 0;
2488cdf0e10cSrcweir sal_uInt32 BytesToSend= n;
2489cdf0e10cSrcweir sal_uInt8 *Ptr = ( sal_uInt8 * )pBuffer;
2490cdf0e10cSrcweir
2491cdf0e10cSrcweir OSL_ASSERT( pSocket );
2492cdf0e10cSrcweir
2493cdf0e10cSrcweir while (BytesToSend > 0)
2494cdf0e10cSrcweir {
2495cdf0e10cSrcweir sal_Int32 RetVal;
2496cdf0e10cSrcweir
2497cdf0e10cSrcweir RetVal= osl_sendSocket( pSocket,Ptr,BytesToSend,osl_Socket_MsgNormal);
2498cdf0e10cSrcweir
2499cdf0e10cSrcweir /* error occured? */
2500cdf0e10cSrcweir if(RetVal <= 0)
2501cdf0e10cSrcweir {
2502cdf0e10cSrcweir break;
2503cdf0e10cSrcweir }
2504cdf0e10cSrcweir
2505cdf0e10cSrcweir BytesToSend -= RetVal;
2506cdf0e10cSrcweir BytesSend += RetVal;
2507cdf0e10cSrcweir Ptr += RetVal;
2508cdf0e10cSrcweir
2509cdf0e10cSrcweir }
2510cdf0e10cSrcweir return BytesSend;
2511cdf0e10cSrcweir }
2512cdf0e10cSrcweir
2513cdf0e10cSrcweir /*****************************************************************************/
2514cdf0e10cSrcweir /* __osl_socket_poll */
2515cdf0e10cSrcweir /*****************************************************************************/
2516cdf0e10cSrcweir
2517cdf0e10cSrcweir #ifdef HAVE_POLL_H /* poll() */
2518cdf0e10cSrcweir
__osl_socket_poll(oslSocket pSocket,const TimeValue * pTimeout,short nEvent)2519cdf0e10cSrcweir sal_Bool __osl_socket_poll (
2520cdf0e10cSrcweir oslSocket pSocket,
2521cdf0e10cSrcweir const TimeValue* pTimeout,
2522cdf0e10cSrcweir short nEvent)
2523cdf0e10cSrcweir {
2524cdf0e10cSrcweir struct pollfd fds;
2525cdf0e10cSrcweir int timeout;
2526cdf0e10cSrcweir int result;
2527cdf0e10cSrcweir
2528cdf0e10cSrcweir OSL_ASSERT(0 != pSocket);
2529cdf0e10cSrcweir if (0 == pSocket)
2530cdf0e10cSrcweir return sal_False; /* EINVAL */
2531cdf0e10cSrcweir
2532cdf0e10cSrcweir pSocket->m_nLastError = 0;
2533cdf0e10cSrcweir
2534cdf0e10cSrcweir fds.fd = pSocket->m_Socket;
2535cdf0e10cSrcweir fds.events = nEvent;
2536cdf0e10cSrcweir fds.revents = 0;
2537cdf0e10cSrcweir
2538cdf0e10cSrcweir timeout = -1;
2539cdf0e10cSrcweir if (pTimeout)
2540cdf0e10cSrcweir {
2541cdf0e10cSrcweir /* Convert to [ms] */
2542cdf0e10cSrcweir timeout = pTimeout->Seconds * 1000;
2543cdf0e10cSrcweir timeout += pTimeout->Nanosec / (1000 * 1000);
2544cdf0e10cSrcweir }
2545cdf0e10cSrcweir
2546cdf0e10cSrcweir result = poll (&fds, 1, timeout);
2547cdf0e10cSrcweir if (result < 0)
2548cdf0e10cSrcweir {
2549cdf0e10cSrcweir pSocket->m_nLastError = errno;
2550cdf0e10cSrcweir OSL_TRACE("__osl_socket_poll(): poll error: %d (%s)",
2551cdf0e10cSrcweir errno, strerror(errno));
2552cdf0e10cSrcweir return sal_False;
2553cdf0e10cSrcweir }
2554cdf0e10cSrcweir if (result == 0)
2555cdf0e10cSrcweir {
2556cdf0e10cSrcweir /* Timeout */
2557cdf0e10cSrcweir return sal_False;
2558cdf0e10cSrcweir }
2559cdf0e10cSrcweir
2560cdf0e10cSrcweir return ((fds.revents & nEvent) == nEvent);
2561cdf0e10cSrcweir }
2562cdf0e10cSrcweir
2563cdf0e10cSrcweir #else /* select() */
2564cdf0e10cSrcweir
__osl_socket_poll(oslSocket pSocket,const TimeValue * pTimeout,short nEvent)2565cdf0e10cSrcweir sal_Bool __osl_socket_poll (
2566cdf0e10cSrcweir oslSocket pSocket,
2567cdf0e10cSrcweir const TimeValue* pTimeout,
2568cdf0e10cSrcweir short nEvent)
2569cdf0e10cSrcweir {
2570cdf0e10cSrcweir fd_set fds;
2571cdf0e10cSrcweir struct timeval tv;
2572cdf0e10cSrcweir int result;
2573cdf0e10cSrcweir
2574cdf0e10cSrcweir OSL_ASSERT(0 != pSocket);
2575cdf0e10cSrcweir if (0 == pSocket)
2576cdf0e10cSrcweir return sal_False; /* EINVAL */
2577cdf0e10cSrcweir
2578cdf0e10cSrcweir pSocket->m_nLastError = 0;
2579cdf0e10cSrcweir
2580cdf0e10cSrcweir FD_ZERO(&fds);
2581cdf0e10cSrcweir FD_SET(pSocket->m_Socket, &fds);
2582cdf0e10cSrcweir
2583cdf0e10cSrcweir if (pTimeout)
2584cdf0e10cSrcweir {
2585cdf0e10cSrcweir /* Convert to 'timeval' */
2586cdf0e10cSrcweir tv.tv_sec = pTimeout->Seconds;
2587cdf0e10cSrcweir tv.tv_usec = pTimeout->Nanosec / 1000;
2588cdf0e10cSrcweir }
2589cdf0e10cSrcweir
2590cdf0e10cSrcweir result = select (
2591cdf0e10cSrcweir pSocket->m_Socket + 1,
2592cdf0e10cSrcweir (nEvent == POLLIN ) ? PTR_FD_SET(fds) : NULL,
2593cdf0e10cSrcweir (nEvent == POLLOUT) ? PTR_FD_SET(fds) : NULL,
2594cdf0e10cSrcweir (nEvent == POLLPRI) ? PTR_FD_SET(fds) : NULL,
2595cdf0e10cSrcweir (pTimeout) ? &tv : NULL);
2596cdf0e10cSrcweir
2597cdf0e10cSrcweir if (result < 0)
2598cdf0e10cSrcweir {
2599cdf0e10cSrcweir pSocket->m_nLastError = errno;
2600cdf0e10cSrcweir OSL_TRACE("__osl_socket_poll(): select error: %d (%s)",
2601cdf0e10cSrcweir errno, strerror(errno));
2602cdf0e10cSrcweir return sal_False;
2603cdf0e10cSrcweir }
2604cdf0e10cSrcweir if (result == 0)
2605cdf0e10cSrcweir {
2606cdf0e10cSrcweir /* Timeout */
2607cdf0e10cSrcweir return sal_False;
2608cdf0e10cSrcweir }
2609cdf0e10cSrcweir
2610cdf0e10cSrcweir return (FD_ISSET(pSocket->m_Socket, &fds) ? sal_True : sal_False);
2611cdf0e10cSrcweir }
2612cdf0e10cSrcweir
2613cdf0e10cSrcweir #endif /* HAVE_POLL_H */
2614cdf0e10cSrcweir
2615cdf0e10cSrcweir /*****************************************************************************/
2616cdf0e10cSrcweir /* osl_isReceiveReady */
2617cdf0e10cSrcweir /*****************************************************************************/
osl_isReceiveReady(oslSocket pSocket,const TimeValue * pTimeout)2618cdf0e10cSrcweir sal_Bool SAL_CALL osl_isReceiveReady (
2619cdf0e10cSrcweir oslSocket pSocket, const TimeValue* pTimeout)
2620cdf0e10cSrcweir {
2621cdf0e10cSrcweir OSL_ASSERT(pSocket);
2622cdf0e10cSrcweir if (pSocket == NULL)
2623cdf0e10cSrcweir {
2624cdf0e10cSrcweir /* ENOTSOCK */
2625cdf0e10cSrcweir return sal_False;
2626cdf0e10cSrcweir }
2627cdf0e10cSrcweir
2628cdf0e10cSrcweir return __osl_socket_poll (pSocket, pTimeout, POLLIN);
2629cdf0e10cSrcweir }
2630cdf0e10cSrcweir
2631cdf0e10cSrcweir /*****************************************************************************/
2632cdf0e10cSrcweir /* osl_isSendReady */
2633cdf0e10cSrcweir /*****************************************************************************/
osl_isSendReady(oslSocket pSocket,const TimeValue * pTimeout)2634cdf0e10cSrcweir sal_Bool SAL_CALL osl_isSendReady (
2635cdf0e10cSrcweir oslSocket pSocket, const TimeValue* pTimeout)
2636cdf0e10cSrcweir {
2637cdf0e10cSrcweir OSL_ASSERT(pSocket);
2638cdf0e10cSrcweir if (pSocket == NULL)
2639cdf0e10cSrcweir {
2640cdf0e10cSrcweir /* ENOTSOCK */
2641cdf0e10cSrcweir return sal_False;
2642cdf0e10cSrcweir }
2643cdf0e10cSrcweir
2644cdf0e10cSrcweir return __osl_socket_poll (pSocket, pTimeout, POLLOUT);
2645cdf0e10cSrcweir }
2646cdf0e10cSrcweir
2647cdf0e10cSrcweir /*****************************************************************************/
2648cdf0e10cSrcweir /* osl_isExceptionPending */
2649cdf0e10cSrcweir /*****************************************************************************/
osl_isExceptionPending(oslSocket pSocket,const TimeValue * pTimeout)2650cdf0e10cSrcweir sal_Bool SAL_CALL osl_isExceptionPending (
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, POLLPRI);
2661cdf0e10cSrcweir }
2662cdf0e10cSrcweir
2663cdf0e10cSrcweir /*****************************************************************************/
2664cdf0e10cSrcweir /* osl_shutdownSocket */
2665cdf0e10cSrcweir /*****************************************************************************/
osl_shutdownSocket(oslSocket pSocket,oslSocketDirection Direction)2666cdf0e10cSrcweir sal_Bool SAL_CALL osl_shutdownSocket(oslSocket pSocket,
2667cdf0e10cSrcweir oslSocketDirection Direction)
2668cdf0e10cSrcweir {
2669cdf0e10cSrcweir int nRet;
2670cdf0e10cSrcweir
2671cdf0e10cSrcweir OSL_ASSERT(pSocket);
2672cdf0e10cSrcweir if ( pSocket == 0 )
2673cdf0e10cSrcweir {
2674cdf0e10cSrcweir return sal_False;
2675cdf0e10cSrcweir }
2676cdf0e10cSrcweir
2677cdf0e10cSrcweir pSocket->m_nLastError=0;
2678cdf0e10cSrcweir
2679cdf0e10cSrcweir nRet=shutdown(pSocket->m_Socket, DIRECTION_TO_NATIVE(Direction));
2680cdf0e10cSrcweir if (nRet != 0 )
2681cdf0e10cSrcweir {
2682cdf0e10cSrcweir pSocket->m_nLastError=errno;
2683cdf0e10cSrcweir OSL_TRACE("shutdown error '%s'\n",strerror(errno));
2684cdf0e10cSrcweir }
2685cdf0e10cSrcweir return (nRet==0);
2686cdf0e10cSrcweir }
2687cdf0e10cSrcweir
2688cdf0e10cSrcweir
2689cdf0e10cSrcweir /*****************************************************************************/
2690cdf0e10cSrcweir /* osl_getSocketOption */
2691cdf0e10cSrcweir /*****************************************************************************/
osl_getSocketOption(oslSocket pSocket,oslSocketOptionLevel Level,oslSocketOption Option,void * pBuffer,sal_uInt32 BufferLen)2692cdf0e10cSrcweir sal_Int32 SAL_CALL osl_getSocketOption(oslSocket pSocket,
2693cdf0e10cSrcweir oslSocketOptionLevel Level,
2694cdf0e10cSrcweir oslSocketOption Option,
2695cdf0e10cSrcweir void* pBuffer,
2696cdf0e10cSrcweir sal_uInt32 BufferLen)
2697cdf0e10cSrcweir {
2698cdf0e10cSrcweir socklen_t nOptLen = (socklen_t) BufferLen;
2699cdf0e10cSrcweir
2700cdf0e10cSrcweir OSL_ASSERT(pSocket);
2701cdf0e10cSrcweir if ( pSocket == 0 )
2702cdf0e10cSrcweir {
2703cdf0e10cSrcweir return -1;
2704cdf0e10cSrcweir }
2705cdf0e10cSrcweir
2706cdf0e10cSrcweir pSocket->m_nLastError=0;
2707cdf0e10cSrcweir
2708cdf0e10cSrcweir if(getsockopt(pSocket->m_Socket,
2709cdf0e10cSrcweir OPTION_LEVEL_TO_NATIVE(Level),
2710cdf0e10cSrcweir OPTION_TO_NATIVE(Option),
2711cdf0e10cSrcweir (sal_Char*)pBuffer,
2712cdf0e10cSrcweir &nOptLen) == -1)
2713cdf0e10cSrcweir {
2714cdf0e10cSrcweir pSocket->m_nLastError=errno;
2715cdf0e10cSrcweir return -1;
2716cdf0e10cSrcweir }
2717cdf0e10cSrcweir
2718cdf0e10cSrcweir return BufferLen;
2719cdf0e10cSrcweir }
2720cdf0e10cSrcweir
2721cdf0e10cSrcweir /*****************************************************************************/
2722cdf0e10cSrcweir /* osl_setSocketOption */
2723cdf0e10cSrcweir /*****************************************************************************/
osl_setSocketOption(oslSocket pSocket,oslSocketOptionLevel Level,oslSocketOption Option,void * pBuffer,sal_uInt32 BufferLen)2724cdf0e10cSrcweir sal_Bool SAL_CALL osl_setSocketOption(oslSocket pSocket,
2725cdf0e10cSrcweir oslSocketOptionLevel Level,
2726cdf0e10cSrcweir oslSocketOption Option,
2727cdf0e10cSrcweir void* pBuffer,
2728cdf0e10cSrcweir sal_uInt32 BufferLen)
2729cdf0e10cSrcweir {
2730cdf0e10cSrcweir int nRet;
2731cdf0e10cSrcweir
2732cdf0e10cSrcweir OSL_ASSERT(pSocket);
2733cdf0e10cSrcweir if ( pSocket == 0 )
2734cdf0e10cSrcweir {
2735cdf0e10cSrcweir return sal_False;
2736cdf0e10cSrcweir }
2737cdf0e10cSrcweir
2738cdf0e10cSrcweir pSocket->m_nLastError=0;
2739cdf0e10cSrcweir
2740cdf0e10cSrcweir nRet = setsockopt(pSocket->m_Socket,
2741cdf0e10cSrcweir OPTION_LEVEL_TO_NATIVE(Level),
2742cdf0e10cSrcweir OPTION_TO_NATIVE(Option),
2743cdf0e10cSrcweir (sal_Char*)pBuffer,
2744cdf0e10cSrcweir BufferLen);
2745cdf0e10cSrcweir
2746cdf0e10cSrcweir if ( nRet < 0 )
2747cdf0e10cSrcweir {
2748cdf0e10cSrcweir pSocket->m_nLastError=errno;
2749cdf0e10cSrcweir return sal_False;
2750cdf0e10cSrcweir }
2751cdf0e10cSrcweir
2752cdf0e10cSrcweir return sal_True;
2753cdf0e10cSrcweir }
2754cdf0e10cSrcweir
2755cdf0e10cSrcweir /*****************************************************************************/
2756cdf0e10cSrcweir /* osl_enableNonBlockingMode */
2757cdf0e10cSrcweir /*****************************************************************************/
osl_enableNonBlockingMode(oslSocket pSocket,sal_Bool On)2758cdf0e10cSrcweir sal_Bool SAL_CALL osl_enableNonBlockingMode(oslSocket pSocket,
2759cdf0e10cSrcweir sal_Bool On)
2760cdf0e10cSrcweir {
2761cdf0e10cSrcweir int flags;
2762cdf0e10cSrcweir int nRet;
2763cdf0e10cSrcweir
2764cdf0e10cSrcweir OSL_ASSERT(pSocket);
2765cdf0e10cSrcweir if ( pSocket == 0 )
2766cdf0e10cSrcweir {
2767cdf0e10cSrcweir return sal_False;
2768cdf0e10cSrcweir }
2769cdf0e10cSrcweir
2770cdf0e10cSrcweir pSocket->m_nLastError=0;
2771cdf0e10cSrcweir
2772cdf0e10cSrcweir flags = fcntl(pSocket->m_Socket, F_GETFL, 0);
2773cdf0e10cSrcweir
2774cdf0e10cSrcweir if (On)
2775cdf0e10cSrcweir flags |= O_NONBLOCK;
2776cdf0e10cSrcweir else
2777cdf0e10cSrcweir flags &= ~(O_NONBLOCK);
2778cdf0e10cSrcweir
2779cdf0e10cSrcweir nRet = fcntl(pSocket->m_Socket, F_SETFL, flags);
2780cdf0e10cSrcweir
2781cdf0e10cSrcweir if ( nRet < 0 )
2782cdf0e10cSrcweir {
2783cdf0e10cSrcweir pSocket->m_nLastError=errno;
2784cdf0e10cSrcweir return sal_False;
2785cdf0e10cSrcweir }
2786cdf0e10cSrcweir
2787cdf0e10cSrcweir return sal_True;
2788cdf0e10cSrcweir }
2789cdf0e10cSrcweir
2790cdf0e10cSrcweir /*****************************************************************************/
2791cdf0e10cSrcweir /* osl_isNonBlockingMode */
2792cdf0e10cSrcweir /*****************************************************************************/
osl_isNonBlockingMode(oslSocket pSocket)2793cdf0e10cSrcweir sal_Bool SAL_CALL osl_isNonBlockingMode(oslSocket pSocket)
2794cdf0e10cSrcweir {
2795cdf0e10cSrcweir int flags;
2796cdf0e10cSrcweir
2797cdf0e10cSrcweir OSL_ASSERT(pSocket);
2798cdf0e10cSrcweir if ( pSocket == 0 )
2799cdf0e10cSrcweir {
2800cdf0e10cSrcweir return sal_False;
2801cdf0e10cSrcweir }
2802cdf0e10cSrcweir
2803cdf0e10cSrcweir pSocket->m_nLastError=0;
2804cdf0e10cSrcweir
2805cdf0e10cSrcweir flags = fcntl(pSocket->m_Socket, F_GETFL, 0);
2806cdf0e10cSrcweir
2807cdf0e10cSrcweir if (flags == -1 || !(flags & O_NONBLOCK))
2808cdf0e10cSrcweir return sal_False;
2809cdf0e10cSrcweir else
2810cdf0e10cSrcweir return sal_True;
2811cdf0e10cSrcweir }
2812cdf0e10cSrcweir
2813cdf0e10cSrcweir /*****************************************************************************/
2814cdf0e10cSrcweir /* osl_getSocketType */
2815cdf0e10cSrcweir /*****************************************************************************/
osl_getSocketType(oslSocket pSocket)2816cdf0e10cSrcweir oslSocketType SAL_CALL osl_getSocketType(oslSocket pSocket)
2817cdf0e10cSrcweir {
2818cdf0e10cSrcweir int Type=0;
2819cdf0e10cSrcweir socklen_t TypeSize= sizeof(Type);
2820cdf0e10cSrcweir
2821cdf0e10cSrcweir OSL_ASSERT(pSocket);
2822cdf0e10cSrcweir if ( pSocket == 0 )
2823cdf0e10cSrcweir {
2824cdf0e10cSrcweir return osl_Socket_TypeInvalid;
2825cdf0e10cSrcweir }
2826cdf0e10cSrcweir
2827cdf0e10cSrcweir pSocket->m_nLastError=0;
2828cdf0e10cSrcweir
2829cdf0e10cSrcweir if(getsockopt(pSocket->m_Socket,
2830cdf0e10cSrcweir OPTION_LEVEL_TO_NATIVE(osl_Socket_LevelSocket),
2831cdf0e10cSrcweir OPTION_TO_NATIVE(osl_Socket_OptionType),
2832cdf0e10cSrcweir (sal_Char*)&Type,
2833cdf0e10cSrcweir &TypeSize) == -1)
2834cdf0e10cSrcweir {
2835cdf0e10cSrcweir /* error */
2836cdf0e10cSrcweir pSocket->m_nLastError=errno;
2837cdf0e10cSrcweir return osl_Socket_TypeInvalid;
2838cdf0e10cSrcweir }
2839cdf0e10cSrcweir
2840cdf0e10cSrcweir return TYPE_FROM_NATIVE(Type);
2841cdf0e10cSrcweir
2842cdf0e10cSrcweir }
2843cdf0e10cSrcweir
2844cdf0e10cSrcweir /*****************************************************************************/
2845cdf0e10cSrcweir /* osl_getLastSocketErrorDescription */
2846cdf0e10cSrcweir /*****************************************************************************/
osl_getLastSocketErrorDescription(oslSocket Socket,rtl_uString ** ustrError)2847cdf0e10cSrcweir void SAL_CALL osl_getLastSocketErrorDescription(oslSocket Socket, rtl_uString **ustrError)
2848cdf0e10cSrcweir {
2849cdf0e10cSrcweir sal_Char pszError[1024];
2850cdf0e10cSrcweir
2851cdf0e10cSrcweir pszError[0] = '\0';
2852cdf0e10cSrcweir
2853cdf0e10cSrcweir osl_psz_getLastSocketErrorDescription(Socket,pszError,sizeof(pszError));
2854cdf0e10cSrcweir
2855cdf0e10cSrcweir rtl_uString_newFromAscii(ustrError,pszError);
2856cdf0e10cSrcweir
2857cdf0e10cSrcweir return;
2858cdf0e10cSrcweir }
2859cdf0e10cSrcweir
2860cdf0e10cSrcweir
osl_psz_getLastSocketErrorDescription(oslSocket pSocket,sal_Char * pBuffer,sal_uInt32 BufferSize)2861cdf0e10cSrcweir void SAL_CALL osl_psz_getLastSocketErrorDescription(oslSocket pSocket, sal_Char* pBuffer, sal_uInt32 BufferSize)
2862cdf0e10cSrcweir {
2863cdf0e10cSrcweir /* make shure pBuffer will be a zero-terminated string even when strncpy has to cut */
2864cdf0e10cSrcweir pBuffer[BufferSize-1]= '\0';
2865cdf0e10cSrcweir
2866cdf0e10cSrcweir if ( pSocket == 0 )
2867cdf0e10cSrcweir {
2868cdf0e10cSrcweir strncpy(pBuffer, strerror(EINVAL), BufferSize-1);
2869cdf0e10cSrcweir return;
2870cdf0e10cSrcweir }
2871cdf0e10cSrcweir
2872cdf0e10cSrcweir strncpy(pBuffer, strerror(pSocket->m_nLastError), BufferSize-1);
2873cdf0e10cSrcweir return;
2874cdf0e10cSrcweir }
2875cdf0e10cSrcweir
2876cdf0e10cSrcweir /*****************************************************************************/
2877cdf0e10cSrcweir /* osl_getLastSocketError */
2878cdf0e10cSrcweir /*****************************************************************************/
osl_getLastSocketError(oslSocket pSocket)2879cdf0e10cSrcweir oslSocketError SAL_CALL osl_getLastSocketError(oslSocket pSocket)
2880cdf0e10cSrcweir {
2881cdf0e10cSrcweir if ( pSocket == 0 )
2882cdf0e10cSrcweir {
2883cdf0e10cSrcweir return ERROR_FROM_NATIVE(EINVAL);
2884cdf0e10cSrcweir }
2885cdf0e10cSrcweir
2886cdf0e10cSrcweir return ERROR_FROM_NATIVE(pSocket->m_nLastError);
2887cdf0e10cSrcweir }
2888cdf0e10cSrcweir
2889cdf0e10cSrcweir /*****************************************************************************/
2890cdf0e10cSrcweir /* SocketSet */
2891cdf0e10cSrcweir /*****************************************************************************/
2892cdf0e10cSrcweir typedef struct _TSocketSetImpl
2893cdf0e10cSrcweir {
2894cdf0e10cSrcweir int m_MaxHandle; /* for select(), the largest descriptor in the set */
2895cdf0e10cSrcweir fd_set m_Set; /* the set of descriptors */
2896cdf0e10cSrcweir
2897cdf0e10cSrcweir } TSocketSetImpl;
2898cdf0e10cSrcweir
2899cdf0e10cSrcweir /*****************************************************************************/
2900cdf0e10cSrcweir /* osl_createSocketSet */
2901cdf0e10cSrcweir /*****************************************************************************/
osl_createSocketSet()2902cdf0e10cSrcweir oslSocketSet SAL_CALL osl_createSocketSet()
2903cdf0e10cSrcweir {
2904cdf0e10cSrcweir TSocketSetImpl* pSet;
2905cdf0e10cSrcweir
2906cdf0e10cSrcweir pSet= (TSocketSetImpl*)malloc(sizeof(TSocketSetImpl));
2907cdf0e10cSrcweir
2908cdf0e10cSrcweir OSL_ASSERT(pSet);
2909cdf0e10cSrcweir
2910cdf0e10cSrcweir if(pSet)
2911cdf0e10cSrcweir {
2912cdf0e10cSrcweir pSet->m_MaxHandle= 0;
2913cdf0e10cSrcweir FD_ZERO(&pSet->m_Set);
2914cdf0e10cSrcweir }
2915cdf0e10cSrcweir
2916cdf0e10cSrcweir return (oslSocketSet)pSet;
2917cdf0e10cSrcweir }
2918cdf0e10cSrcweir
2919cdf0e10cSrcweir /*****************************************************************************/
2920cdf0e10cSrcweir /* osl_destroySocketSet */
2921cdf0e10cSrcweir /*****************************************************************************/
osl_destroySocketSet(oslSocketSet Set)2922cdf0e10cSrcweir void SAL_CALL osl_destroySocketSet(oslSocketSet Set)
2923cdf0e10cSrcweir {
2924cdf0e10cSrcweir if(Set)
2925cdf0e10cSrcweir free(Set);
2926cdf0e10cSrcweir }
2927cdf0e10cSrcweir
2928cdf0e10cSrcweir /*****************************************************************************/
2929cdf0e10cSrcweir /* osl_clearSocketSet */
2930cdf0e10cSrcweir /*****************************************************************************/
osl_clearSocketSet(oslSocketSet Set)2931cdf0e10cSrcweir void SAL_CALL osl_clearSocketSet(oslSocketSet Set)
2932cdf0e10cSrcweir {
2933cdf0e10cSrcweir TSocketSetImpl* pSet;
2934cdf0e10cSrcweir OSL_ASSERT(Set);
2935cdf0e10cSrcweir if ( Set == 0 )
2936cdf0e10cSrcweir {
2937cdf0e10cSrcweir return;
2938cdf0e10cSrcweir }
2939cdf0e10cSrcweir
2940cdf0e10cSrcweir pSet= (TSocketSetImpl*)Set;
2941cdf0e10cSrcweir pSet->m_MaxHandle= 0;
2942cdf0e10cSrcweir
2943cdf0e10cSrcweir FD_ZERO(&pSet->m_Set);
2944cdf0e10cSrcweir }
2945cdf0e10cSrcweir
2946cdf0e10cSrcweir /*****************************************************************************/
2947cdf0e10cSrcweir /* osl_addToSocketSet */
2948cdf0e10cSrcweir /*****************************************************************************/
osl_addToSocketSet(oslSocketSet Set,oslSocket pSocket)2949cdf0e10cSrcweir void SAL_CALL osl_addToSocketSet(oslSocketSet Set, oslSocket pSocket)
2950cdf0e10cSrcweir {
2951cdf0e10cSrcweir TSocketSetImpl* pSet;
2952cdf0e10cSrcweir
2953cdf0e10cSrcweir OSL_ASSERT(Set);
2954cdf0e10cSrcweir OSL_ASSERT(pSocket);
2955cdf0e10cSrcweir
2956cdf0e10cSrcweir if ( Set == 0 || pSocket == 0)
2957cdf0e10cSrcweir {
2958cdf0e10cSrcweir return;
2959cdf0e10cSrcweir }
2960cdf0e10cSrcweir
2961cdf0e10cSrcweir pSet= (TSocketSetImpl*)Set;
2962cdf0e10cSrcweir
2963cdf0e10cSrcweir /* correct max handle */
2964cdf0e10cSrcweir if(pSocket->m_Socket > pSet->m_MaxHandle)
2965cdf0e10cSrcweir pSet->m_MaxHandle= pSocket->m_Socket;
2966cdf0e10cSrcweir FD_SET(pSocket->m_Socket, &pSet->m_Set);
2967cdf0e10cSrcweir
2968cdf0e10cSrcweir }
2969cdf0e10cSrcweir
2970cdf0e10cSrcweir /*****************************************************************************/
2971cdf0e10cSrcweir /* osl_removeFromSocketSet */
2972cdf0e10cSrcweir /*****************************************************************************/
osl_removeFromSocketSet(oslSocketSet Set,oslSocket pSocket)2973cdf0e10cSrcweir void SAL_CALL osl_removeFromSocketSet(oslSocketSet Set, oslSocket pSocket)
2974cdf0e10cSrcweir {
2975cdf0e10cSrcweir TSocketSetImpl* pSet;
2976cdf0e10cSrcweir
2977cdf0e10cSrcweir OSL_ASSERT(Set);
2978cdf0e10cSrcweir OSL_ASSERT(pSocket);
2979cdf0e10cSrcweir
2980cdf0e10cSrcweir if ( Set == 0 || pSocket == 0)
2981cdf0e10cSrcweir {
2982cdf0e10cSrcweir return;
2983cdf0e10cSrcweir }
2984cdf0e10cSrcweir
2985cdf0e10cSrcweir pSet= (TSocketSetImpl*)Set;
2986cdf0e10cSrcweir
2987cdf0e10cSrcweir /* correct max handle */
2988cdf0e10cSrcweir if(pSocket->m_Socket == pSet->m_MaxHandle)
2989cdf0e10cSrcweir {
2990cdf0e10cSrcweir /* not optimal, since the next used descriptor might be */
2991cdf0e10cSrcweir /* much smaller than m_Socket-1, but it will do */
2992cdf0e10cSrcweir pSet->m_MaxHandle--;
2993cdf0e10cSrcweir if(pSet->m_MaxHandle < 0)
2994cdf0e10cSrcweir {
2995cdf0e10cSrcweir pSet->m_MaxHandle= 0; /* avoid underflow */
2996cdf0e10cSrcweir }
2997cdf0e10cSrcweir }
2998cdf0e10cSrcweir
2999cdf0e10cSrcweir FD_CLR(pSocket->m_Socket, &pSet->m_Set);
3000cdf0e10cSrcweir }
3001cdf0e10cSrcweir
3002cdf0e10cSrcweir /*****************************************************************************/
3003cdf0e10cSrcweir /* osl_isInSocketSet */
3004cdf0e10cSrcweir /*****************************************************************************/
osl_isInSocketSet(oslSocketSet Set,oslSocket pSocket)3005cdf0e10cSrcweir sal_Bool SAL_CALL osl_isInSocketSet(oslSocketSet Set, oslSocket pSocket)
3006cdf0e10cSrcweir {
3007cdf0e10cSrcweir TSocketSetImpl* pSet;
3008cdf0e10cSrcweir
3009cdf0e10cSrcweir OSL_ASSERT(Set);
3010cdf0e10cSrcweir OSL_ASSERT(pSocket);
3011cdf0e10cSrcweir if ( Set == 0 || pSocket == 0 )
3012cdf0e10cSrcweir {
3013cdf0e10cSrcweir return sal_False;
3014cdf0e10cSrcweir }
3015cdf0e10cSrcweir
3016cdf0e10cSrcweir pSet= (TSocketSetImpl*)Set;
3017cdf0e10cSrcweir
3018cdf0e10cSrcweir return (FD_ISSET(pSocket->m_Socket, &pSet->m_Set) != 0);
3019cdf0e10cSrcweir }
3020cdf0e10cSrcweir
3021cdf0e10cSrcweir /*****************************************************************************/
3022cdf0e10cSrcweir /* osl_demultiplexSocketEvents */
3023cdf0e10cSrcweir /*****************************************************************************/
osl_demultiplexSocketEvents(oslSocketSet IncomingSet,oslSocketSet OutgoingSet,oslSocketSet OutOfBandSet,const TimeValue * pTimeout)3024cdf0e10cSrcweir sal_Int32 SAL_CALL osl_demultiplexSocketEvents(oslSocketSet IncomingSet,
3025cdf0e10cSrcweir oslSocketSet OutgoingSet,
3026cdf0e10cSrcweir oslSocketSet OutOfBandSet,
3027cdf0e10cSrcweir const TimeValue* pTimeout)
3028cdf0e10cSrcweir {
3029cdf0e10cSrcweir int MaxHandle= 0;
3030cdf0e10cSrcweir struct timeval tv;
3031cdf0e10cSrcweir TSocketSetImpl* pInSet;
3032cdf0e10cSrcweir TSocketSetImpl* pOutSet;
3033cdf0e10cSrcweir TSocketSetImpl* pOOBSet;
3034cdf0e10cSrcweir
3035cdf0e10cSrcweir if (pTimeout)
3036cdf0e10cSrcweir {
3037cdf0e10cSrcweir /* non-blocking call */
3038cdf0e10cSrcweir tv.tv_sec = pTimeout->Seconds;
3039cdf0e10cSrcweir tv.tv_usec = pTimeout->Nanosec / 1000L;
3040cdf0e10cSrcweir }
3041cdf0e10cSrcweir
3042cdf0e10cSrcweir /* map opaque data to impl-types */
3043cdf0e10cSrcweir pInSet= (TSocketSetImpl*)IncomingSet;
3044cdf0e10cSrcweir pOutSet= (TSocketSetImpl*)OutgoingSet;
3045cdf0e10cSrcweir pOOBSet= (TSocketSetImpl*)OutOfBandSet;
3046cdf0e10cSrcweir
3047cdf0e10cSrcweir /* get max handle from all sets */
3048cdf0e10cSrcweir if (pInSet)
3049cdf0e10cSrcweir MaxHandle= pInSet->m_MaxHandle;
3050cdf0e10cSrcweir
3051cdf0e10cSrcweir if (pOutSet && (pOutSet->m_MaxHandle > MaxHandle))
3052cdf0e10cSrcweir MaxHandle= pOutSet->m_MaxHandle;
3053cdf0e10cSrcweir
3054cdf0e10cSrcweir if (pOOBSet && (pOOBSet->m_MaxHandle > MaxHandle))
3055cdf0e10cSrcweir MaxHandle= pOOBSet->m_MaxHandle;
3056cdf0e10cSrcweir
3057cdf0e10cSrcweir return select(MaxHandle+1,
3058cdf0e10cSrcweir pInSet ? PTR_FD_SET(pInSet->m_Set) : 0,
3059cdf0e10cSrcweir pOutSet ? PTR_FD_SET(pOutSet->m_Set) : 0,
3060cdf0e10cSrcweir pOOBSet ? PTR_FD_SET(pOOBSet->m_Set) : 0,
3061cdf0e10cSrcweir pTimeout ? &tv : 0);
3062cdf0e10cSrcweir }
3063cdf0e10cSrcweir
3064