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