OLD | NEW |
1 /* This Source Code Form is subject to the terms of the Mozilla Public | 1 /* This Source Code Form is subject to the terms of the Mozilla Public |
2 * License, v. 2.0. If a copy of the MPL was not distributed with this | 2 * License, v. 2.0. If a copy of the MPL was not distributed with this |
3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ | 3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ |
4 /* | 4 /* |
5 * pkix_pl_socket.c | 5 * pkix_pl_socket.c |
6 * | 6 * |
7 * Socket Function Definitions | 7 * Socket Function Definitions |
8 * | 8 * |
9 */ | 9 */ |
10 | 10 |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
53 * is whatever the system call provides. | 53 * is whatever the system call provides. |
54 * | 54 * |
55 * PARAMETERS: | 55 * PARAMETERS: |
56 * none | 56 * none |
57 * THREAD SAFETY: | 57 * THREAD SAFETY: |
58 * Thread Safe (see Thread Safety definitions in Programmer's Guide) | 58 * Thread Safe (see Thread Safety definitions in Programmer's Guide) |
59 * RETURNS: | 59 * RETURNS: |
60 * none | 60 * none |
61 */ | 61 */ |
62 static void pkix_pl_socket_timestamp() { | 62 static void pkix_pl_socket_timestamp() { |
63 PRInt64 prTime; | 63 PRInt64 prTime; |
64 prTime = PR_Now(); | 64 prTime = PR_Now(); |
65 printf("%lld:\n", prTime); | 65 printf("%lld:\n", prTime); |
66 } | 66 } |
67 | 67 |
68 /* | 68 /* |
69 * FUNCTION: pkix_pl_socket_hexDigit | 69 * FUNCTION: pkix_pl_socket_hexDigit |
70 * DESCRIPTION: | 70 * DESCRIPTION: |
71 * | 71 * |
72 * This functions prints to stdout the byte "byteVal" as two hex digits. | 72 * This functions prints to stdout the byte "byteVal" as two hex digits. |
73 * | 73 * |
74 * PARAMETERS: | 74 * PARAMETERS: |
75 * "byteVal" | 75 * "byteVal" |
76 * The value to be printed. | 76 * The value to be printed. |
77 * THREAD SAFETY: | 77 * THREAD SAFETY: |
78 * Thread Safe (see Thread Safety definitions in Programmer's Guide) | 78 * Thread Safe (see Thread Safety definitions in Programmer's Guide) |
79 * RETURNS: | 79 * RETURNS: |
80 * none | 80 * none |
81 */ | 81 */ |
82 static void pkix_pl_socket_hexDigit(char byteVal) { | 82 static void pkix_pl_socket_hexDigit(char byteVal) { |
83 int n = 0; | 83 int n = 0; |
84 char cHi = '\0'; | 84 char cHi = '\0'; |
85 char cLow = '\0'; | 85 char cLow = '\0'; |
86 n = ((byteVal >> 4) & 0xf); | 86 n = ((byteVal >> 4) & 0xf); |
87 if (n > 9) { | 87 if (n > 9) { |
88 cHi = (char) ((n - 10) + 'A'); | 88 cHi = (char)((n - 10) + 'A'); |
89 } else { | 89 } else { |
90 cHi = (char) (n + '0'); | 90 cHi = (char)(n + '0'); |
91 } | 91 } |
92 n = byteVal & 0xf; | 92 n = byteVal & 0xf; |
93 if (n > 9) { | 93 if (n > 9) { |
94 cLow = (char) ((n - 10) + 'A'); | 94 cLow = (char)((n - 10) + 'A'); |
95 } else { | 95 } else { |
96 cLow = (char) (n + '0'); | 96 cLow = (char)(n + '0'); |
97 } | 97 } |
98 (void) printf("%c%c", cHi, cLow); | 98 (void)printf("%c%c", cHi, cLow); |
99 } | 99 } |
100 | 100 |
101 /* | 101 /* |
102 * FUNCTION: pkix_pl_socket_linePrefix | 102 * FUNCTION: pkix_pl_socket_linePrefix |
103 * DESCRIPTION: | 103 * DESCRIPTION: |
104 * | 104 * |
105 * This functions prints to stdout the address provided by "addr" as four | 105 * This functions prints to stdout the address provided by "addr" as four |
106 * hexadecimal digits followed by a colon and a space. | 106 * hexadecimal digits followed by a colon and a space. |
107 * | 107 * |
108 * PARAMETERS: | 108 * PARAMETERS: |
109 * "addr" | 109 * "addr" |
110 * The address to be printed | 110 * The address to be printed |
111 * none | 111 * none |
112 * THREAD SAFETY: | 112 * THREAD SAFETY: |
113 * Thread Safe (see Thread Safety definitions in Programmer's Guide) | 113 * Thread Safe (see Thread Safety definitions in Programmer's Guide) |
114 * RETURNS: | 114 * RETURNS: |
115 * none | 115 * none |
116 */ | 116 */ |
117 static void pkix_pl_socket_linePrefix(PKIX_UInt32 addr) { | 117 static void pkix_pl_socket_linePrefix(PKIX_UInt32 addr) { |
118 pkix_pl_socket_hexDigit((char)((addr >> 8) & 0xff)); | 118 pkix_pl_socket_hexDigit((char)((addr >> 8) & 0xff)); |
119 pkix_pl_socket_hexDigit((char)(addr & 0xff)); | 119 pkix_pl_socket_hexDigit((char)(addr & 0xff)); |
120 (void) printf(": "); | 120 (void)printf(": "); |
121 } | 121 } |
122 | 122 |
123 /* | 123 /* |
124 * FUNCTION: pkix_pl_socket_traceLine | 124 * FUNCTION: pkix_pl_socket_traceLine |
125 * DESCRIPTION: | 125 * DESCRIPTION: |
126 * | 126 * |
127 * This functions prints to stdout the sixteen bytes beginning at the | 127 * This functions prints to stdout the sixteen bytes beginning at the |
128 * address pointed to by "ptr". The bytes are printed as sixteen pairs | 128 * address pointed to by "ptr". The bytes are printed as sixteen pairs |
129 * of hexadecimal characters followed by an ascii interpretation, in which | 129 * of hexadecimal characters followed by an ascii interpretation, in which |
130 * characters from 0x20 to 0x7d are shown as their ascii equivalents, and | 130 * characters from 0x20 to 0x7d are shown as their ascii equivalents, and |
131 * other values are represented as periods. | 131 * other values are represented as periods. |
132 * | 132 * |
133 * PARAMETERS: | 133 * PARAMETERS: |
134 * "ptr" | 134 * "ptr" |
135 * The address of the first of the bytes to be printed | 135 * The address of the first of the bytes to be printed |
136 * THREAD SAFETY: | 136 * THREAD SAFETY: |
137 * Thread Safe (see Thread Safety definitions in Programmer's Guide) | 137 * Thread Safe (see Thread Safety definitions in Programmer's Guide) |
138 * RETURNS: | 138 * RETURNS: |
139 * none | 139 * none |
140 */ | 140 */ |
141 static void pkix_pl_socket_traceLine(char *ptr) { | 141 static void pkix_pl_socket_traceLine(char *ptr) { |
142 PKIX_UInt32 i = 0; | 142 PKIX_UInt32 i = 0; |
143 pkix_pl_socket_linePrefix((PKIX_UInt32)ptr); | 143 pkix_pl_socket_linePrefix((PKIX_UInt32)ptr); |
144 for (i = 0; i < 16; i++) { | 144 for (i = 0; i < 16; i++) { |
145 printf(" "); | 145 printf(" "); |
146 pkix_pl_socket_hexDigit(ptr[i]); | 146 pkix_pl_socket_hexDigit(ptr[i]); |
147 if (i == 7) { | 147 if (i == 7) { |
148 printf(" "); | 148 printf(" "); |
149 } | 149 } |
150 } | 150 } |
151 printf(" "); | 151 printf(" "); |
152 for (i = 0; i < 16; i++) { | 152 for (i = 0; i < 16; i++) { |
153 if ((ptr[i] < ' ') || (ptr[i] > '}')) { | 153 if ((ptr[i] < ' ') || (ptr[i] > '}')) { |
154 printf("."); | 154 printf("."); |
155 } else { | 155 } else { |
156 printf("%c", ptr[i]); | 156 printf("%c", ptr[i]); |
157 } | 157 } |
158 } | 158 } |
159 printf("\n"); | 159 printf("\n"); |
160 } | 160 } |
161 | 161 |
162 /* | 162 /* |
163 * FUNCTION: pkix_pl_socket_tracePartialLine | 163 * FUNCTION: pkix_pl_socket_tracePartialLine |
164 * DESCRIPTION: | 164 * DESCRIPTION: |
165 * | 165 * |
166 * This functions prints to stdout the number of bytes given by "nBytes", | 166 * This functions prints to stdout the number of bytes given by "nBytes", |
167 * beginning at the address pointed to by "ptr". The bytes are printed as | 167 * beginning at the address pointed to by "ptr". The bytes are printed as |
168 * pairs of hexadecimal characters followed by an ascii interpretation, in | 168 * pairs of hexadecimal characters followed by an ascii interpretation, in |
169 * which characters from 0x20 to 0x7d are shown as their ascii equivalents, | 169 * which characters from 0x20 to 0x7d are shown as their ascii equivalents, |
170 * and other values are represented as periods. | 170 * and other values are represented as periods. |
171 * | 171 * |
172 * PARAMETERS: | 172 * PARAMETERS: |
173 * "ptr" | 173 * "ptr" |
174 * The address of the first of the bytes to be printed | 174 * The address of the first of the bytes to be printed |
175 * "nBytes" | 175 * "nBytes" |
176 * The Int32 value giving the number of bytes to be printed. If "nBytes" | 176 * The Int32 value giving the number of bytes to be printed. If "nBytes" |
177 * is greater than sixteen, the results will be unattractive. | 177 * is greater than sixteen, the results will be unattractive. |
178 * none | 178 * none |
179 * THREAD SAFETY: | 179 * THREAD SAFETY: |
180 * Thread Safe (see Thread Safety definitions in Programmer's Guide) | 180 * Thread Safe (see Thread Safety definitions in Programmer's Guide) |
181 * RETURNS: | 181 * RETURNS: |
182 * none | 182 * none |
183 */ | 183 */ |
184 static void pkix_pl_socket_tracePartialLine(char *ptr, PKIX_UInt32 nBytes) { | 184 static void pkix_pl_socket_tracePartialLine(char *ptr, PKIX_UInt32 nBytes) { |
185 PKIX_UInt32 i = 0; | 185 PKIX_UInt32 i = 0; |
186 if (nBytes > 0) { | 186 if (nBytes > 0) { |
187 pkix_pl_socket_linePrefix((PKIX_UInt32)ptr); | 187 pkix_pl_socket_linePrefix((PKIX_UInt32)ptr); |
188 } | 188 } |
189 for (i = 0; i < nBytes; i++) { | 189 for (i = 0; i < nBytes; i++) { |
190 printf(" "); | 190 printf(" "); |
191 pkix_pl_socket_hexDigit(ptr[i]); | 191 pkix_pl_socket_hexDigit(ptr[i]); |
192 if (i == 7) { | 192 if (i == 7) { |
193 printf(" "); | 193 printf(" "); |
194 } | 194 } |
195 } | 195 } |
196 for (i = nBytes; i < 16; i++) { | 196 for (i = nBytes; i < 16; i++) { |
197 printf(" "); | 197 printf(" "); |
198 if (i == 7) { | 198 if (i == 7) { |
199 printf(" "); | 199 printf(" "); |
200 } | 200 } |
201 } | 201 } |
202 printf(" "); | 202 printf(" "); |
203 for (i = 0; i < nBytes; i++) { | 203 for (i = 0; i < nBytes; i++) { |
204 if ((ptr[i] < ' ') || (ptr[i] > '}')) { | 204 if ((ptr[i] < ' ') || (ptr[i] > '}')) { |
205 printf("."); | 205 printf("."); |
206 } else { | 206 } else { |
207 printf("%c", ptr[i]); | 207 printf("%c", ptr[i]); |
208 } | 208 } |
209 } | 209 } |
210 printf("\n"); | 210 printf("\n"); |
211 } | 211 } |
212 | 212 |
213 /* | 213 /* |
214 * FUNCTION: pkix_pl_socket_tracebuff | 214 * FUNCTION: pkix_pl_socket_tracebuff |
215 * DESCRIPTION: | 215 * DESCRIPTION: |
216 * | 216 * |
217 * This functions prints to stdout the number of bytes given by "nBytes", | 217 * This functions prints to stdout the number of bytes given by "nBytes", |
218 * beginning with the byte pointed to by "buf". The output is preceded by | 218 * beginning with the byte pointed to by "buf". The output is preceded by |
219 * a timestamp, and each group of sixteen (and a remainder, if any) is | 219 * a timestamp, and each group of sixteen (and a remainder, if any) is |
220 * preceded by its address. The contents are shown in hexadecimal and as | 220 * preceded by its address. The contents are shown in hexadecimal and as |
221 * ascii characters. If "nBytes" is zero, the timestamp and starting | 221 * ascii characters. If "nBytes" is zero, the timestamp and starting |
222 * address are displayed. | 222 * address are displayed. |
223 * | 223 * |
224 * PARAMETERS: | 224 * PARAMETERS: |
225 * "buf" | 225 * "buf" |
226 * The starting address of the bytes to be printed | 226 * The starting address of the bytes to be printed |
227 * "nBytes" | 227 * "nBytes" |
228 * The number of bytes to be printed | 228 * The number of bytes to be printed |
229 * THREAD SAFETY: | 229 * THREAD SAFETY: |
230 * Thread Safe (see Thread Safety definitions in Programmer's Guide) | 230 * Thread Safe (see Thread Safety definitions in Programmer's Guide) |
231 * RETURNS: | 231 * RETURNS: |
232 * none | 232 * none |
233 */ | 233 */ |
234 void pkix_pl_socket_tracebuff(void *buf, PKIX_UInt32 nBytes) { | 234 void pkix_pl_socket_tracebuff(void *buf, PKIX_UInt32 nBytes) { |
235 PKIX_UInt32 bytesRemaining = nBytes; | 235 PKIX_UInt32 bytesRemaining = nBytes; |
236 PKIX_UInt32 offset = 0; | 236 PKIX_UInt32 offset = 0; |
237 char *bufptr = (char *)buf; | 237 char *bufptr = (char *)buf; |
238 | 238 |
239 if (socketTraceFlag == PKIX_FALSE) return; | 239 if (socketTraceFlag == PKIX_FALSE) return; |
240 | 240 |
241 pkix_pl_socket_timestamp(); | 241 pkix_pl_socket_timestamp(); |
242 /* | 242 /* |
243 * Special case: if called with length of zero, just do address | 243 * Special case: if called with length of zero, just do address |
244 */ | 244 */ |
245 if (nBytes == 0) { | 245 if (nBytes == 0) { |
246 pkix_pl_socket_linePrefix((PKIX_UInt32)buf); | 246 pkix_pl_socket_linePrefix((PKIX_UInt32)buf); |
247 printf("\n"); | 247 printf("\n"); |
248 } else { | 248 } else { |
249 while (bytesRemaining >= 16) { | 249 while (bytesRemaining >= 16) { |
250 pkix_pl_socket_traceLine(&bufptr[offset]); | 250 pkix_pl_socket_traceLine(&bufptr[offset]); |
251 bytesRemaining -= 16; | 251 bytesRemaining -= 16; |
252 offset += 16; | 252 offset += 16; |
253 } | 253 } |
254 pkix_pl_socket_tracePartialLine | 254 pkix_pl_socket_tracePartialLine(&bufptr[offset], bytesRemaining); |
255 (&bufptr[offset], bytesRemaining); | 255 } |
256 } | |
257 } | 256 } |
258 | 257 |
259 #endif | 258 #endif |
260 | 259 |
261 /* | 260 /* |
262 * FUNCTION: pkix_pl_Socket_SetNonBlocking | 261 * FUNCTION: pkix_pl_Socket_SetNonBlocking |
263 * DESCRIPTION: | 262 * DESCRIPTION: |
264 * | 263 * |
265 * This functions sets the socket represented by the PRFileDesc "fileDesc" | 264 * This functions sets the socket represented by the PRFileDesc "fileDesc" |
266 * to nonblocking mode. | 265 * to nonblocking mode. |
267 * | 266 * |
268 * PARAMETERS: | 267 * PARAMETERS: |
269 * "fileDesc" | 268 * "fileDesc" |
270 * The address of the PRFileDesc whose I/O mode is to be set | 269 * The address of the PRFileDesc whose I/O mode is to be set |
271 * non-blocking. Must be non-NULL. | 270 * non-blocking. Must be non-NULL. |
272 * "plContext" | 271 * "plContext" |
273 * Platform-specific context pointer | 272 * Platform-specific context pointer |
274 * THREAD SAFETY: | 273 * THREAD SAFETY: |
275 * Thread Safe (see Thread Safety definitions in Programmer's Guide) | 274 * Thread Safe (see Thread Safety definitions in Programmer's Guide) |
276 * RETURNS: | 275 * RETURNS: |
277 * none | 276 * none |
278 */ | 277 */ |
279 static PKIX_Error * | 278 static PKIX_Error *pkix_pl_Socket_SetNonBlocking(PRFileDesc *fileDesc, |
280 pkix_pl_Socket_SetNonBlocking( | 279 void *plContext) { |
281 PRFileDesc *fileDesc, | 280 PRStatus rv = PR_FAILURE; |
282 void *plContext) | 281 PRSocketOptionData sockOptionData; |
283 { | |
284 PRStatus rv = PR_FAILURE; | |
285 PRSocketOptionData sockOptionData; | |
286 | 282 |
287 PKIX_ENTER(SOCKET, "pkix_pl_Socket_SetNonBlocking"); | 283 PKIX_ENTER(SOCKET, "pkix_pl_Socket_SetNonBlocking"); |
288 PKIX_NULLCHECK_ONE(fileDesc); | 284 PKIX_NULLCHECK_ONE(fileDesc); |
289 | 285 |
290 sockOptionData.option = PR_SockOpt_Nonblocking; | 286 sockOptionData.option = PR_SockOpt_Nonblocking; |
291 sockOptionData.value.non_blocking = PR_TRUE; | 287 sockOptionData.value.non_blocking = PR_TRUE; |
292 | 288 |
293 PKIX_PL_NSSCALLRV(SOCKET, rv, fileDesc->methods->setsocketoption, | 289 PKIX_PL_NSSCALLRV(SOCKET, rv, fileDesc->methods->setsocketoption, |
294 (fileDesc, &sockOptionData)); | 290 (fileDesc, &sockOptionData)); |
295 | 291 |
296 if (rv != PR_SUCCESS) { | 292 if (rv != PR_SUCCESS) { |
297 PKIX_ERROR(PKIX_UNABLETOSETSOCKETTONONBLOCKING); | 293 PKIX_ERROR(PKIX_UNABLETOSETSOCKETTONONBLOCKING); |
298 } | 294 } |
299 cleanup: | 295 cleanup: |
300 | 296 |
301 PKIX_RETURN(SOCKET); | 297 PKIX_RETURN(SOCKET); |
302 } | 298 } |
303 | 299 |
304 /* | 300 /* |
305 * FUNCTION: pkix_pl_Socket_CreateClient | 301 * FUNCTION: pkix_pl_Socket_CreateClient |
306 * DESCRIPTION: | 302 * DESCRIPTION: |
307 * | 303 * |
308 * This functions creates a client socket for the PKIX_PL_Socket pointed to | 304 * This functions creates a client socket for the PKIX_PL_Socket pointed to |
309 * by "socket". If "socket" was created with a timeout value of zero, the | 305 * by "socket". If "socket" was created with a timeout value of zero, the |
310 * client socket is set to use nonblocking I/O. | 306 * client socket is set to use nonblocking I/O. |
311 * | 307 * |
312 * PARAMETERS: | 308 * PARAMETERS: |
313 * "socket" | 309 * "socket" |
314 * The address of the Socket for which a client socket is to be | 310 * The address of the Socket for which a client socket is to be |
315 * created. Must be non-NULL. | 311 * created. Must be non-NULL. |
316 * "plContext" | 312 * "plContext" |
317 * Platform-specific context pointer | 313 * Platform-specific context pointer |
318 * THREAD SAFETY: | 314 * THREAD SAFETY: |
319 * Thread Safe (see Thread Safety definitions in Programmer's Guide) | 315 * Thread Safe (see Thread Safety definitions in Programmer's Guide) |
320 * RETURNS: | 316 * RETURNS: |
321 * none | 317 * none |
322 */ | 318 */ |
323 | 319 |
324 static PKIX_Error * | 320 static PKIX_Error *pkix_pl_Socket_CreateClient(PKIX_PL_Socket *socket, |
325 pkix_pl_Socket_CreateClient( | 321 void *plContext) { |
326 PKIX_PL_Socket *socket, | |
327 void *plContext) | |
328 { | |
329 #ifdef PKIX_SOCKETDEBUG | 322 #ifdef PKIX_SOCKETDEBUG |
330 PRErrorCode errorcode = 0; | 323 PRErrorCode errorcode = 0; |
331 #endif | 324 #endif |
332 PRFileDesc *mySock = NULL; | 325 PRFileDesc *mySock = NULL; |
333 | 326 |
334 PKIX_ENTER(SOCKET, "pkix_pl_Socket_CreateClient"); | 327 PKIX_ENTER(SOCKET, "pkix_pl_Socket_CreateClient"); |
335 PKIX_NULLCHECK_ONE(socket); | 328 PKIX_NULLCHECK_ONE(socket); |
336 | 329 |
337 PKIX_PL_NSSCALLRV(SOCKET, mySock, PR_NewTCPSocket, ()); | 330 PKIX_PL_NSSCALLRV(SOCKET, mySock, PR_NewTCPSocket, ()); |
338 if (!mySock) { | 331 if (!mySock) { |
339 #ifdef PKIX_SOCKETDEBUG | 332 #ifdef PKIX_SOCKETDEBUG |
340 errorcode = PR_GetError(); | 333 errorcode = PR_GetError(); |
341 printf | 334 printf("pkix_pl_Socket_CreateClient: %s\n", |
342 ("pkix_pl_Socket_CreateClient: %s\n", | 335 PR_ErrorToString(errorcode, PR_LANGUAGE_EN)); |
343 PR_ErrorToString(errorcode, PR_LANGUAGE_EN)); | |
344 #endif | 336 #endif |
345 PKIX_ERROR(PKIX_PRNEWTCPSOCKETFAILED); | 337 PKIX_ERROR(PKIX_PRNEWTCPSOCKETFAILED); |
346 } | 338 } |
347 | 339 |
348 #ifdef PKIX_SOCKETDEBUG | 340 #ifdef PKIX_SOCKETDEBUG |
349 printf("Created socket, PRFileDesc @ %#X\n", mySock); | 341 printf("Created socket, PRFileDesc @ %#X\n", mySock); |
350 #endif | 342 #endif |
351 | 343 |
352 socket->clientSock = mySock; | 344 socket->clientSock = mySock; |
353 socket->status = SOCKET_UNCONNECTED; | 345 socket->status = SOCKET_UNCONNECTED; |
354 if (socket->timeout == 0) { | 346 if (socket->timeout == 0) { |
355 PKIX_CHECK(pkix_pl_Socket_SetNonBlocking(mySock, plContext), | 347 PKIX_CHECK(pkix_pl_Socket_SetNonBlocking(mySock, plContext), |
356 PKIX_SOCKETSETNONBLOCKINGFAILED); | 348 PKIX_SOCKETSETNONBLOCKINGFAILED); |
357 } | 349 } |
358 | 350 |
359 cleanup: | 351 cleanup: |
360 | 352 |
361 PKIX_RETURN(SOCKET); | 353 PKIX_RETURN(SOCKET); |
362 } | 354 } |
363 | 355 |
364 /* | 356 /* |
365 * FUNCTION: pkix_pl_Socket_CreateServer | 357 * FUNCTION: pkix_pl_Socket_CreateServer |
366 * DESCRIPTION: | 358 * DESCRIPTION: |
367 * | 359 * |
368 * This functions creates a server socket for the PKIX_PL_Socket pointed to | 360 * This functions creates a server socket for the PKIX_PL_Socket pointed to |
369 * by "socket". If "socket" was created with a timeout value of zero, the | 361 * by "socket". If "socket" was created with a timeout value of zero, the |
370 * server socket is set to use nonblocking I/O. | 362 * server socket is set to use nonblocking I/O. |
371 * | 363 * |
372 * Warning: there seems to be a problem with operating a server socket in | 364 * Warning: there seems to be a problem with operating a server socket in |
373 * non-blocking mode. If the server calls Recv prior to a corresponding | 365 * non-blocking mode. If the server calls Recv prior to a corresponding |
374 * Send, the message may be lost. | 366 * Send, the message may be lost. |
375 * | 367 * |
376 * PARAMETERS: | 368 * PARAMETERS: |
377 * "socket" | 369 * "socket" |
378 * The address of the Socket for which a server socket is to be | 370 * The address of the Socket for which a server socket is to be |
379 * created. Must be non-NULL. | 371 * created. Must be non-NULL. |
380 * "plContext" | 372 * "plContext" |
381 * Platform-specific context pointer | 373 * Platform-specific context pointer |
382 * THREAD SAFETY: | 374 * THREAD SAFETY: |
383 * Thread Safe (see Thread Safety definitions in Programmer's Guide) | 375 * Thread Safe (see Thread Safety definitions in Programmer's Guide) |
384 * RETURNS: | 376 * RETURNS: |
385 * none | 377 * none |
386 */ | 378 */ |
387 static PKIX_Error * | 379 static PKIX_Error *pkix_pl_Socket_CreateServer(PKIX_PL_Socket *socket, |
388 pkix_pl_Socket_CreateServer( | 380 void *plContext) { |
389 PKIX_PL_Socket *socket, | 381 /* #ifdef PKIX_SOCKETDEBUG */ |
390 void *plContext) | 382 PRErrorCode errorcode = 0; |
391 { | 383 /* #endif */ |
392 /* #ifdef PKIX_SOCKETDEBUG */ | 384 PRStatus rv = PR_FAILURE; |
393 PRErrorCode errorcode = 0; | 385 PRFileDesc *serverSock = NULL; |
394 /* #endif */ | 386 PRSocketOptionData sockOptionData; |
395 PRStatus rv = PR_FAILURE; | |
396 PRFileDesc *serverSock = NULL; | |
397 PRSocketOptionData sockOptionData; | |
398 | 387 |
399 PKIX_ENTER(SOCKET, "pkix_pl_Socket_CreateServer"); | 388 PKIX_ENTER(SOCKET, "pkix_pl_Socket_CreateServer"); |
400 PKIX_NULLCHECK_ONE(socket); | 389 PKIX_NULLCHECK_ONE(socket); |
401 | 390 |
402 PKIX_PL_NSSCALLRV(SOCKET, serverSock, PR_NewTCPSocket, ()); | 391 PKIX_PL_NSSCALLRV(SOCKET, serverSock, PR_NewTCPSocket, ()); |
403 if (!serverSock) { | 392 if (!serverSock) { |
404 #ifdef PKIX_SOCKETDEBUG | 393 #ifdef PKIX_SOCKETDEBUG |
405 errorcode = PR_GetError(); | 394 errorcode = PR_GetError(); |
406 printf | 395 printf("pkix_pl_Socket_CreateServer: %s\n", |
407 ("pkix_pl_Socket_CreateServer: %s\n", | 396 PR_ErrorToString(errorcode, PR_LANGUAGE_EN)); |
408 PR_ErrorToString(errorcode, PR_LANGUAGE_EN)); | |
409 #endif | 397 #endif |
410 PKIX_ERROR(PKIX_PRNEWTCPSOCKETFAILED); | 398 PKIX_ERROR(PKIX_PRNEWTCPSOCKETFAILED); |
411 } | 399 } |
412 | 400 |
413 socket->serverSock = serverSock; | 401 socket->serverSock = serverSock; |
414 | 402 |
415 #ifdef PKIX_SOCKETDEBUG | 403 #ifdef PKIX_SOCKETDEBUG |
416 printf("Created socket, PRFileDesc @ %#X\n", serverSock); | 404 printf("Created socket, PRFileDesc @ %#X\n", serverSock); |
417 #endif | 405 #endif |
418 | 406 |
419 if (socket->timeout == 0) { | 407 if (socket->timeout == 0) { |
420 PKIX_CHECK(pkix_pl_Socket_SetNonBlocking(serverSock, plContext), | 408 PKIX_CHECK(pkix_pl_Socket_SetNonBlocking(serverSock, plContext), |
421 PKIX_SOCKETSETNONBLOCKINGFAILED); | 409 PKIX_SOCKETSETNONBLOCKINGFAILED); |
422 } | 410 } |
423 | 411 |
424 sockOptionData.option = PR_SockOpt_Reuseaddr; | 412 sockOptionData.option = PR_SockOpt_Reuseaddr; |
425 sockOptionData.value.reuse_addr = PR_TRUE; | 413 sockOptionData.value.reuse_addr = PR_TRUE; |
426 | 414 |
427 PKIX_PL_NSSCALLRV(SOCKET, rv, serverSock->methods->setsocketoption, | 415 PKIX_PL_NSSCALLRV(SOCKET, rv, serverSock->methods->setsocketoption, |
428 (serverSock, &sockOptionData)); | 416 (serverSock, &sockOptionData)); |
429 | 417 |
430 if (rv != PR_SUCCESS) { | 418 if (rv != PR_SUCCESS) { |
431 PKIX_ERROR(PKIX_UNABLETOSETSOCKETTONONBLOCKING); | 419 PKIX_ERROR(PKIX_UNABLETOSETSOCKETTONONBLOCKING); |
432 } | 420 } |
433 | 421 |
434 PKIX_PL_NSSCALLRV(SOCKET, rv, PR_Bind, (serverSock, socket->netAddr)); | 422 PKIX_PL_NSSCALLRV(SOCKET, rv, PR_Bind, (serverSock, socket->netAddr)); |
435 | 423 |
436 if (rv == PR_FAILURE) { | 424 if (rv == PR_FAILURE) { |
437 /* #ifdef PKIX_SOCKETDEBUG */ | 425 /* #ifdef PKIX_SOCKETDEBUG */ |
438 errorcode = PR_GetError(); | 426 errorcode = PR_GetError(); |
439 printf | 427 printf("pkix_pl_Socket_CreateServer: %s\n", |
440 ("pkix_pl_Socket_CreateServer: %s\n", | 428 PR_ErrorToString(errorcode, PR_LANGUAGE_EN)); |
441 PR_ErrorToString(errorcode, PR_LANGUAGE_EN)); | 429 /* #endif */ |
442 /* #endif */ | 430 PKIX_ERROR(PKIX_PRBINDFAILED); |
443 PKIX_ERROR(PKIX_PRBINDFAILED); | 431 } |
444 } | |
445 | 432 |
446 #ifdef PKIX_SOCKETDEBUG | 433 #ifdef PKIX_SOCKETDEBUG |
447 printf("Successful bind!\n"); | 434 printf("Successful bind!\n"); |
448 #endif | 435 #endif |
449 | 436 |
450 socket->status = SOCKET_BOUND; | 437 socket->status = SOCKET_BOUND; |
451 | 438 |
452 cleanup: | 439 cleanup: |
453 | 440 |
454 PKIX_RETURN(SOCKET); | 441 PKIX_RETURN(SOCKET); |
455 } | 442 } |
456 | 443 |
457 /* | 444 /* |
458 * FUNCTION: pkix_pl_Socket_Connect | 445 * FUNCTION: pkix_pl_Socket_Connect |
459 * DESCRIPTION: | 446 * DESCRIPTION: |
460 * | 447 * |
461 * This functions performs the connect function for the client socket | 448 * This functions performs the connect function for the client socket |
462 * specified in "socket", storing the status at "pStatus". | 449 * specified in "socket", storing the status at "pStatus". |
463 * | 450 * |
464 * PARAMETERS: | 451 * PARAMETERS: |
465 * "socket" | 452 * "socket" |
466 * The address of the Socket for which a connect is to be performed. | 453 * The address of the Socket for which a connect is to be performed. |
467 * Must be non-NULL. | 454 * Must be non-NULL. |
468 * "pStatus" | 455 * "pStatus" |
469 * The address at which the connection status is stored. Must be non-NULL. | 456 * The address at which the connection status is stored. Must be non-NULL. |
470 * "plContext" | 457 * "plContext" |
471 * Platform-specific context pointer | 458 * Platform-specific context pointer |
472 * THREAD SAFETY: | 459 * THREAD SAFETY: |
473 * Thread Safe (see Thread Safety definitions in Programmer's Guide) | 460 * Thread Safe (see Thread Safety definitions in Programmer's Guide) |
474 * RETURNS: | 461 * RETURNS: |
475 * none | 462 * none |
476 */ | 463 */ |
477 static PKIX_Error * | 464 static PKIX_Error *pkix_pl_Socket_Connect(PKIX_PL_Socket *socket, |
478 pkix_pl_Socket_Connect( | 465 PRErrorCode *pStatus, |
479 PKIX_PL_Socket *socket, | 466 void *plContext) { |
480 PRErrorCode *pStatus, | 467 PRStatus rv = PR_FAILURE; |
481 void *plContext) | 468 PRErrorCode errorcode = 0; |
482 { | |
483 PRStatus rv = PR_FAILURE; | |
484 PRErrorCode errorcode = 0; | |
485 | 469 |
486 PKIX_ENTER(SOCKET, "pkix_pl_Socket_Connect"); | 470 PKIX_ENTER(SOCKET, "pkix_pl_Socket_Connect"); |
487 PKIX_NULLCHECK_TWO(socket, socket->clientSock); | 471 PKIX_NULLCHECK_TWO(socket, socket->clientSock); |
488 | 472 |
489 PKIX_PL_NSSCALLRV(SOCKET, rv, PR_Connect, | 473 PKIX_PL_NSSCALLRV(SOCKET, rv, PR_Connect, |
490 (socket->clientSock, socket->netAddr, socket->timeout)); | 474 (socket->clientSock, socket->netAddr, socket->timeout)); |
491 | 475 |
492 if (rv == PR_FAILURE) { | 476 if (rv == PR_FAILURE) { |
493 errorcode = PR_GetError(); | 477 errorcode = PR_GetError(); |
494 *pStatus = errorcode; | 478 *pStatus = errorcode; |
495 if (errorcode == PR_IN_PROGRESS_ERROR) { | 479 if (errorcode == PR_IN_PROGRESS_ERROR) { |
496 socket->status = SOCKET_CONNECTPENDING; | 480 socket->status = SOCKET_CONNECTPENDING; |
497 goto cleanup; | 481 goto cleanup; |
498 } else { | 482 } else { |
499 #ifdef PKIX_SOCKETDEBUG | 483 #ifdef PKIX_SOCKETDEBUG |
500 printf | 484 printf("pkix_pl_Socket_Connect: %s\n", |
501 ("pkix_pl_Socket_Connect: %s\n", | 485 PR_ErrorToString(errorcode, PR_LANGUAGE_EN)); |
502 PR_ErrorToString(errorcode, PR_LANGUAGE_EN)); | |
503 #endif | 486 #endif |
504 PKIX_ERROR(PKIX_PRCONNECTFAILED); | 487 PKIX_ERROR(PKIX_PRCONNECTFAILED); |
505 } | 488 } |
506 } | 489 } |
507 | 490 |
508 #ifdef PKIX_SOCKETDEBUG | 491 #ifdef PKIX_SOCKETDEBUG |
509 printf("Successful connect!\n"); | 492 printf("Successful connect!\n"); |
510 #endif | 493 #endif |
511 | 494 |
512 *pStatus = 0; | 495 *pStatus = 0; |
513 socket->status = SOCKET_CONNECTED; | 496 socket->status = SOCKET_CONNECTED; |
514 | 497 |
515 cleanup: | 498 cleanup: |
516 | 499 |
517 PKIX_RETURN(SOCKET); | 500 PKIX_RETURN(SOCKET); |
518 } | 501 } |
519 | 502 |
520 /* | 503 /* |
521 * FUNCTION: pkix_pl_Socket_ConnectContinue | 504 * FUNCTION: pkix_pl_Socket_ConnectContinue |
522 * DESCRIPTION: | 505 * DESCRIPTION: |
523 * | 506 * |
524 * This functions continues the connect function for the client socket | 507 * This functions continues the connect function for the client socket |
525 * specified in "socket", storing the status at "pStatus". It is expected that | 508 * specified in "socket", storing the status at "pStatus". It is expected that |
526 * the non-blocking connect has returned PR_IN_PROGRESS_ERROR. | 509 * the non-blocking connect has returned PR_IN_PROGRESS_ERROR. |
527 * | 510 * |
528 * PARAMETERS: | 511 * PARAMETERS: |
529 * "socket" | 512 * "socket" |
530 * The address of the Socket for which a connect is to be continued. | 513 * The address of the Socket for which a connect is to be continued. |
531 * Must be non-NULL. | 514 * Must be non-NULL. |
532 * "pStatus" | 515 * "pStatus" |
533 * The address at which the connection status is stored. Must be non-NULL. | 516 * The address at which the connection status is stored. Must be non-NULL. |
534 * "plContext" | 517 * "plContext" |
535 * Platform-specific context pointer | 518 * Platform-specific context pointer |
536 * THREAD SAFETY: | 519 * THREAD SAFETY: |
537 * Thread Safe (see Thread Safety definitions in Programmer's Guide) | 520 * Thread Safe (see Thread Safety definitions in Programmer's Guide) |
538 * RETURNS: | 521 * RETURNS: |
539 * none | 522 * none |
540 */ | 523 */ |
541 static PKIX_Error * | 524 static PKIX_Error *pkix_pl_Socket_ConnectContinue(PKIX_PL_Socket *socket, |
542 pkix_pl_Socket_ConnectContinue( | 525 PRErrorCode *pStatus, |
543 PKIX_PL_Socket *socket, | 526 void *plContext) { |
544 PRErrorCode *pStatus, | 527 PRStatus rv = PR_FAILURE; |
545 void *plContext) | 528 PRErrorCode errorcode = 0; |
546 { | 529 PRPollDesc pollDesc; |
547 PRStatus rv = PR_FAILURE; | 530 PRInt32 numEvents = 0; |
548 PRErrorCode errorcode = 0; | 531 |
549 PRPollDesc pollDesc; | 532 PKIX_ENTER(SOCKET, "pkix_pl_Socket_ConnectContinue"); |
550 PRInt32 numEvents = 0; | 533 PKIX_NULLCHECK_TWO(socket, socket->clientSock); |
551 | 534 |
552 PKIX_ENTER(SOCKET, "pkix_pl_Socket_ConnectContinue"); | 535 pollDesc.fd = socket->clientSock; |
553 PKIX_NULLCHECK_TWO(socket, socket->clientSock); | 536 pollDesc.in_flags = PR_POLL_WRITE | PR_POLL_EXCEPT; |
554 | 537 pollDesc.out_flags = 0; |
555 pollDesc.fd = socket->clientSock; | 538 PKIX_PL_NSSCALLRV(SOCKET, numEvents, PR_Poll, (&pollDesc, 1, 0)); |
556 pollDesc.in_flags = PR_POLL_WRITE | PR_POLL_EXCEPT; | 539 if (numEvents < 0) { |
557 pollDesc.out_flags = 0; | 540 PKIX_ERROR(PKIX_PRPOLLFAILED); |
558 PKIX_PL_NSSCALLRV(SOCKET, numEvents, PR_Poll, (&pollDesc, 1, 0)); | 541 } |
559 if (numEvents < 0) { | 542 |
560 PKIX_ERROR(PKIX_PRPOLLFAILED); | 543 if (numEvents == 0) { |
561 } | 544 *pStatus = PR_IN_PROGRESS_ERROR; |
562 | 545 goto cleanup; |
563 if (numEvents == 0) { | 546 } |
564 *pStatus = PR_IN_PROGRESS_ERROR; | 547 |
565 goto cleanup; | 548 PKIX_PL_NSSCALLRV(SOCKET, rv, PR_ConnectContinue, |
566 } | 549 (socket->clientSock, pollDesc.out_flags)); |
567 | 550 |
568 PKIX_PL_NSSCALLRV(SOCKET, rv, PR_ConnectContinue, | 551 /* |
569 (socket->clientSock, pollDesc.out_flags)); | 552 * PR_ConnectContinue sometimes lies. It returns PR_SUCCESS |
570 | 553 * even though the connection is not yet ready. But its deceit |
571 /* | 554 * is betrayed by the contents of out_flags! |
572 * PR_ConnectContinue sometimes lies. It returns PR_SUCCESS | 555 */ |
573 * even though the connection is not yet ready. But its deceit | 556 if ((rv == PR_SUCCESS) && (pollDesc.out_flags == PR_POLL_ERR)) { |
574 * is betrayed by the contents of out_flags! | 557 *pStatus = PR_IN_PROGRESS_ERROR; |
575 */ | 558 goto cleanup; |
576 if ((rv == PR_SUCCESS) && (pollDesc.out_flags == PR_POLL_ERR)) { | 559 } |
577 *pStatus = PR_IN_PROGRESS_ERROR; | 560 |
578 goto cleanup; | 561 if (rv == PR_FAILURE) { |
579 } | 562 errorcode = PR_GetError(); |
580 | 563 *pStatus = errorcode; |
581 if (rv == PR_FAILURE) { | 564 if (errorcode == PR_IN_PROGRESS_ERROR) { |
582 errorcode = PR_GetError(); | 565 goto cleanup; |
583 *pStatus = errorcode; | 566 } else { |
584 if (errorcode == PR_IN_PROGRESS_ERROR) { | |
585 goto cleanup; | |
586 } else { | |
587 #ifdef PKIX_SOCKETDEBUG | 567 #ifdef PKIX_SOCKETDEBUG |
588 printf | 568 printf("pkix_pl_Socket_ConnectContinue: %s\n", |
589 ("pkix_pl_Socket_ConnectContinue: %s\n", | 569 PR_ErrorToString(errorcode, PR_LANGUAGE_EN)); |
590 PR_ErrorToString(errorcode, PR_LANGUAGE_EN)); | |
591 #endif | 570 #endif |
592 PKIX_ERROR(PKIX_PRCONNECTCONTINUEFAILED); | 571 PKIX_ERROR(PKIX_PRCONNECTCONTINUEFAILED); |
593 } | 572 } |
594 } | 573 } |
595 | 574 |
596 #ifdef PKIX_SOCKETDEBUG | 575 #ifdef PKIX_SOCKETDEBUG |
597 printf("Successful connect!\n"); | 576 printf("Successful connect!\n"); |
598 #endif | 577 #endif |
599 | 578 |
600 *pStatus = 0; | 579 *pStatus = 0; |
601 socket->status = SOCKET_CONNECTED; | 580 socket->status = SOCKET_CONNECTED; |
602 | 581 |
603 cleanup: | 582 cleanup: |
604 | 583 |
605 PKIX_RETURN(SOCKET); | 584 PKIX_RETURN(SOCKET); |
606 } | 585 } |
607 | 586 |
608 /* | 587 /* |
609 * FUNCTION: pkix_pl_Socket_Destroy | 588 * FUNCTION: pkix_pl_Socket_Destroy |
610 * (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h) | 589 * (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h) |
611 */ | 590 */ |
612 static PKIX_Error * | 591 static PKIX_Error *pkix_pl_Socket_Destroy(PKIX_PL_Object *object, |
613 pkix_pl_Socket_Destroy( | 592 void *plContext) { |
614 PKIX_PL_Object *object, | 593 PKIX_PL_Socket *socket = NULL; |
615 void *plContext) | 594 |
616 { | 595 PKIX_ENTER(SOCKET, "pkix_pl_Socket_Destroy"); |
617 PKIX_PL_Socket *socket = NULL; | 596 PKIX_NULLCHECK_ONE(object); |
618 | 597 |
619 PKIX_ENTER(SOCKET, "pkix_pl_Socket_Destroy"); | 598 PKIX_CHECK(pkix_CheckType(object, PKIX_SOCKET_TYPE, plContext), |
620 PKIX_NULLCHECK_ONE(object); | 599 PKIX_OBJECTNOTANSOCKET); |
621 | 600 |
622 PKIX_CHECK(pkix_CheckType | 601 socket = (PKIX_PL_Socket *)object; |
623 (object, PKIX_SOCKET_TYPE, plContext), | 602 |
624 PKIX_OBJECTNOTANSOCKET); | 603 if (socket->isServer) { |
625 | 604 if (socket->serverSock) { |
626 socket = (PKIX_PL_Socket *)object; | 605 PR_Close(socket->serverSock); |
627 | 606 } |
628 if (socket->isServer) { | 607 } else { |
629 if (socket->serverSock) { | 608 if (socket->clientSock) { |
630 PR_Close(socket->serverSock); | 609 PR_Close(socket->clientSock); |
631 } | 610 } |
632 } else { | 611 } |
633 if (socket->clientSock) { | 612 |
634 PR_Close(socket->clientSock); | 613 cleanup: |
635 } | 614 |
636 } | 615 PKIX_RETURN(SOCKET); |
637 | |
638 cleanup: | |
639 | |
640 PKIX_RETURN(SOCKET); | |
641 } | 616 } |
642 | 617 |
643 /* | 618 /* |
644 * FUNCTION: pkix_pl_Socket_Hashcode | 619 * FUNCTION: pkix_pl_Socket_Hashcode |
645 * (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h) | 620 * (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h) |
646 */ | 621 */ |
647 static PKIX_Error * | 622 static PKIX_Error *pkix_pl_Socket_Hashcode(PKIX_PL_Object *object, |
648 pkix_pl_Socket_Hashcode( | 623 PKIX_UInt32 *pHashcode, |
649 PKIX_PL_Object *object, | 624 void *plContext) { |
650 PKIX_UInt32 *pHashcode, | 625 PKIX_PL_Socket *socket = NULL; |
651 void *plContext) | 626 |
652 { | 627 PKIX_ENTER(SOCKET, "pkix_pl_Socket_Hashcode"); |
653 PKIX_PL_Socket *socket = NULL; | 628 PKIX_NULLCHECK_TWO(object, pHashcode); |
654 | 629 |
655 PKIX_ENTER(SOCKET, "pkix_pl_Socket_Hashcode"); | 630 PKIX_CHECK(pkix_CheckType(object, PKIX_SOCKET_TYPE, plContext), |
656 PKIX_NULLCHECK_TWO(object, pHashcode); | 631 PKIX_OBJECTNOTSOCKET); |
657 | 632 |
658 PKIX_CHECK(pkix_CheckType(object, PKIX_SOCKET_TYPE, plContext), | 633 socket = (PKIX_PL_Socket *)object; |
659 PKIX_OBJECTNOTSOCKET); | 634 |
660 | 635 *pHashcode = (((socket->timeout << 3) + (socket->netAddr->inet.family << 3)) + |
661 socket = (PKIX_PL_Socket *)object; | 636 (*((PKIX_UInt32 *)&(socket->netAddr->inet.ip)))) + |
662 | 637 socket->netAddr->inet.port; |
663 *pHashcode = (((socket->timeout << 3) + | 638 |
664 (socket->netAddr->inet.family << 3)) + | 639 cleanup: |
665 (*((PKIX_UInt32 *)&(socket->netAddr->inet.ip)))) + | 640 |
666 socket->netAddr->inet.port; | 641 PKIX_RETURN(SOCKET); |
667 | |
668 cleanup: | |
669 | |
670 PKIX_RETURN(SOCKET); | |
671 } | 642 } |
672 | 643 |
673 /* | 644 /* |
674 * FUNCTION: pkix_pl_Socket_Equals | 645 * FUNCTION: pkix_pl_Socket_Equals |
675 * (see comments for PKIX_PL_EqualsCallback in pkix_pl_system.h) | 646 * (see comments for PKIX_PL_EqualsCallback in pkix_pl_system.h) |
676 */ | 647 */ |
677 static PKIX_Error * | 648 static PKIX_Error *pkix_pl_Socket_Equals(PKIX_PL_Object *firstObject, |
678 pkix_pl_Socket_Equals( | 649 PKIX_PL_Object *secondObject, |
679 PKIX_PL_Object *firstObject, | 650 PKIX_Int32 *pResult, void *plContext) { |
680 PKIX_PL_Object *secondObject, | 651 PKIX_PL_Socket *firstSocket = NULL; |
681 PKIX_Int32 *pResult, | 652 PKIX_PL_Socket *secondSocket = NULL; |
682 void *plContext) | 653 |
683 { | 654 PKIX_ENTER(SOCKET, "pkix_pl_Socket_Equals"); |
684 PKIX_PL_Socket *firstSocket = NULL; | 655 PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult); |
685 PKIX_PL_Socket *secondSocket = NULL; | 656 |
686 | 657 *pResult = PKIX_FALSE; |
687 PKIX_ENTER(SOCKET, "pkix_pl_Socket_Equals"); | 658 |
688 PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult); | 659 PKIX_CHECK( |
689 | 660 pkix_CheckTypes(firstObject, secondObject, PKIX_SOCKET_TYPE, plContext), |
690 *pResult = PKIX_FALSE; | 661 PKIX_OBJECTNOTSOCKET); |
691 | 662 |
692 PKIX_CHECK(pkix_CheckTypes | 663 firstSocket = (PKIX_PL_Socket *)firstObject; |
693 (firstObject, secondObject, PKIX_SOCKET_TYPE, plContext), | 664 secondSocket = (PKIX_PL_Socket *)secondObject; |
694 PKIX_OBJECTNOTSOCKET); | 665 |
695 | 666 if (firstSocket->timeout != secondSocket->timeout) { |
696 firstSocket = (PKIX_PL_Socket *)firstObject; | 667 goto cleanup; |
697 secondSocket = (PKIX_PL_Socket *)secondObject; | 668 } |
698 | 669 |
699 if (firstSocket->timeout != secondSocket->timeout) { | 670 if (firstSocket->netAddr == secondSocket->netAddr) { |
700 goto cleanup; | 671 *pResult = PKIX_TRUE; |
701 } | 672 goto cleanup; |
702 | 673 } |
703 if (firstSocket->netAddr == secondSocket->netAddr) { | 674 |
704 *pResult = PKIX_TRUE; | 675 if ((firstSocket->netAddr->inet.family != |
705 goto cleanup; | 676 secondSocket->netAddr->inet.family) || |
706 } | 677 (*((PKIX_UInt32 *)&(firstSocket->netAddr->inet.ip)) != |
707 | 678 *((PKIX_UInt32 *)&(secondSocket->netAddr->inet.ip))) || |
708 if ((firstSocket->netAddr->inet.family != | 679 (firstSocket->netAddr->inet.port != secondSocket->netAddr->inet.port)) { |
709 secondSocket->netAddr->inet.family) || | 680 |
710 (*((PKIX_UInt32 *)&(firstSocket->netAddr->inet.ip)) != | 681 goto cleanup; |
711 *((PKIX_UInt32 *)&(secondSocket->netAddr->inet.ip))) || | 682 } |
712 (firstSocket->netAddr->inet.port != | 683 |
713 secondSocket->netAddr->inet.port)) { | 684 *pResult = PKIX_TRUE; |
714 | 685 |
715 goto cleanup; | 686 cleanup: |
716 | 687 |
717 } | 688 PKIX_RETURN(SOCKET); |
718 | |
719 *pResult = PKIX_TRUE; | |
720 | |
721 cleanup: | |
722 | |
723 PKIX_RETURN(SOCKET); | |
724 } | 689 } |
725 | 690 |
726 /* | 691 /* |
727 * FUNCTION: pkix_pl_Socket_RegisterSelf | 692 * FUNCTION: pkix_pl_Socket_RegisterSelf |
728 * | 693 * |
729 * DESCRIPTION: | 694 * DESCRIPTION: |
730 * Registers PKIX_PL_SOCKET_TYPE and its related | 695 * Registers PKIX_PL_SOCKET_TYPE and its related |
731 * functions with systemClasses[] | 696 * functions with systemClasses[] |
732 * | 697 * |
733 * THREAD SAFETY: | 698 * THREAD SAFETY: |
734 * Not Thread Safe - for performance and complexity reasons | 699 * Not Thread Safe - for performance and complexity reasons |
735 * | 700 * |
736 * Since this function is only called by PKIX_PL_Initialize, which should | 701 * Since this function is only called by PKIX_PL_Initialize, which should |
737 * only be called once, it is acceptable that this function is not | 702 * only be called once, it is acceptable that this function is not |
738 * thread-safe. | 703 * thread-safe. |
739 */ | 704 */ |
740 PKIX_Error * | 705 PKIX_Error *pkix_pl_Socket_RegisterSelf(void *plContext) { |
741 pkix_pl_Socket_RegisterSelf(void *plContext) | 706 extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES]; |
742 { | 707 pkix_ClassTable_Entry entry; |
743 extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES]; | 708 |
744 pkix_ClassTable_Entry entry; | 709 PKIX_ENTER(SOCKET, "pkix_pl_Socket_RegisterSelf"); |
745 | 710 |
746 PKIX_ENTER(SOCKET, "pkix_pl_Socket_RegisterSelf"); | 711 entry.description = "Socket"; |
747 | 712 entry.objCounter = 0; |
748 entry.description = "Socket"; | 713 entry.typeObjectSize = sizeof(PKIX_PL_Socket); |
749 entry.objCounter = 0; | 714 entry.destructor = pkix_pl_Socket_Destroy; |
750 entry.typeObjectSize = sizeof(PKIX_PL_Socket); | 715 entry.equalsFunction = pkix_pl_Socket_Equals; |
751 entry.destructor = pkix_pl_Socket_Destroy; | 716 entry.hashcodeFunction = pkix_pl_Socket_Hashcode; |
752 entry.equalsFunction = pkix_pl_Socket_Equals; | 717 entry.toStringFunction = NULL; |
753 entry.hashcodeFunction = pkix_pl_Socket_Hashcode; | 718 entry.comparator = NULL; |
754 entry.toStringFunction = NULL; | 719 entry.duplicateFunction = NULL; |
755 entry.comparator = NULL; | 720 |
756 entry.duplicateFunction = NULL; | 721 systemClasses[PKIX_SOCKET_TYPE] = entry; |
757 | |
758 systemClasses[PKIX_SOCKET_TYPE] = entry; | |
759 | 722 |
760 #ifdef PKIX_SOCKETTRACE | 723 #ifdef PKIX_SOCKETTRACE |
761 { | 724 { |
762 char *val = NULL; | 725 char *val = NULL; |
763 val = PR_GetEnv("SOCKETTRACE"); | 726 val = PR_GetEnv("SOCKETTRACE"); |
764 /* Is SOCKETTRACE set in the environment? */ | 727 /* Is SOCKETTRACE set in the environment? */ |
765 if ((val != NULL) && (*val != '\0')) { | 728 if ((val != NULL) && (*val != '\0')) { |
766 socketTraceFlag = | 729 socketTraceFlag = ((*val == '1') ? PKIX_TRUE : PKIX_FALSE); |
767 ((*val == '1')?PKIX_TRUE:PKIX_FALSE); | 730 } |
768 } | 731 } |
769 } | |
770 #endif | 732 #endif |
771 | 733 |
772 PKIX_RETURN(SOCKET); | 734 PKIX_RETURN(SOCKET); |
773 } | 735 } |
774 | 736 |
775 /* --Public-Socket-Functions----------------------------------- */ | 737 /* --Public-Socket-Functions----------------------------------- */ |
776 | 738 |
777 /* | 739 /* |
778 * FUNCTION: pkix_pl_Socket_Listen | 740 * FUNCTION: pkix_pl_Socket_Listen |
779 * DESCRIPTION: | 741 * DESCRIPTION: |
780 * | 742 * |
781 * This functions establishes a listening queue for the server Socket | 743 * This functions establishes a listening queue for the server Socket |
782 * pointed to by "socket". | 744 * pointed to by "socket". |
783 * | 745 * |
784 * PARAMETERS: | 746 * PARAMETERS: |
785 * "socket" | 747 * "socket" |
786 * The address of the server socket for which the queue is to be | 748 * The address of the server socket for which the queue is to be |
787 * established. Must be non-NULL. | 749 * established. Must be non-NULL. |
788 * "backlog" | 750 * "backlog" |
789 * The UInt32 value of the length of the queue to be established. | 751 * The UInt32 value of the length of the queue to be established. |
790 * "plContext" | 752 * "plContext" |
791 * Platform-specific context pointer | 753 * Platform-specific context pointer |
792 * THREAD SAFETY: | 754 * THREAD SAFETY: |
793 * Thread Safe (see Thread Safety definitions in Programmer's Guide) | 755 * Thread Safe (see Thread Safety definitions in Programmer's Guide) |
794 * RETURNS: | 756 * RETURNS: |
795 * none | 757 * none |
796 */ | 758 */ |
797 static PKIX_Error * | 759 static PKIX_Error *pkix_pl_Socket_Listen(PKIX_PL_Socket *socket, |
798 pkix_pl_Socket_Listen( | 760 PKIX_UInt32 backlog, void *plContext) { |
799 PKIX_PL_Socket *socket, | |
800 PKIX_UInt32 backlog, | |
801 void *plContext) | |
802 { | |
803 #ifdef PKIX_SOCKETDEBUG | 761 #ifdef PKIX_SOCKETDEBUG |
804 PRErrorCode errorcode = 0; | 762 PRErrorCode errorcode = 0; |
805 #endif | 763 #endif |
806 PRStatus rv = PR_FAILURE; | 764 PRStatus rv = PR_FAILURE; |
807 | 765 |
808 PKIX_ENTER(SOCKET, "pkix_pl_Socket_Listen"); | 766 PKIX_ENTER(SOCKET, "pkix_pl_Socket_Listen"); |
809 PKIX_NULLCHECK_TWO(socket, socket->serverSock); | 767 PKIX_NULLCHECK_TWO(socket, socket->serverSock); |
810 | 768 |
811 PKIX_PL_NSSCALLRV(SOCKET, rv, PR_Listen, | 769 PKIX_PL_NSSCALLRV(SOCKET, rv, PR_Listen, |
812 (socket->serverSock, (PRIntn)backlog)); | 770 (socket->serverSock, (PRIntn)backlog)); |
813 | 771 |
814 if (rv == PR_FAILURE) { | 772 if (rv == PR_FAILURE) { |
815 #ifdef PKIX_SOCKETDEBUG | 773 #ifdef PKIX_SOCKETDEBUG |
816 errorcode = PR_GetError(); | 774 errorcode = PR_GetError(); |
817 printf | 775 printf("pkix_pl_Socket_Listen: %s\n", |
818 ("pkix_pl_Socket_Listen: %s\n", | 776 PR_ErrorToString(errorcode, PR_LANGUAGE_EN)); |
819 PR_ErrorToString(errorcode, PR_LANGUAGE_EN)); | |
820 #endif | 777 #endif |
821 PKIX_ERROR(PKIX_PRLISTENFAILED); | 778 PKIX_ERROR(PKIX_PRLISTENFAILED); |
822 } | 779 } |
823 | 780 |
824 #ifdef PKIX_SOCKETDEBUG | 781 #ifdef PKIX_SOCKETDEBUG |
825 printf("Successful listen!\n"); | 782 printf("Successful listen!\n"); |
826 #endif | 783 #endif |
827 | 784 |
828 socket->status = SOCKET_LISTENING; | 785 socket->status = SOCKET_LISTENING; |
829 cleanup: | 786 cleanup: |
830 | 787 |
831 PKIX_RETURN(SOCKET); | 788 PKIX_RETURN(SOCKET); |
832 } | 789 } |
833 | 790 |
834 /* | 791 /* |
835 * FUNCTION: pkix_pl_Socket_Shutdown | 792 * FUNCTION: pkix_pl_Socket_Shutdown |
836 * DESCRIPTION: | 793 * DESCRIPTION: |
837 * | 794 * |
838 * This functions performs the shutdown of any connections controlled by the | 795 * This functions performs the shutdown of any connections controlled by the |
839 * socket pointed to by "socket". | 796 * socket pointed to by "socket". |
840 * | 797 * |
841 * PARAMETERS: | 798 * PARAMETERS: |
842 * "socket" | 799 * "socket" |
843 * The address of the socket to be shut down. Must be non-NULL. | 800 * The address of the socket to be shut down. Must be non-NULL. |
844 * "plContext" | 801 * "plContext" |
845 * Platform-specific context pointer | 802 * Platform-specific context pointer |
846 * THREAD SAFETY: | 803 * THREAD SAFETY: |
847 * Thread Safe (see Thread Safety definitions in Programmer's Guide) | 804 * Thread Safe (see Thread Safety definitions in Programmer's Guide) |
848 * RETURNS: | 805 * RETURNS: |
849 * none | 806 * none |
850 */ | 807 */ |
851 static PKIX_Error * | 808 static PKIX_Error *pkix_pl_Socket_Shutdown(PKIX_PL_Socket *socket, |
852 pkix_pl_Socket_Shutdown( | 809 void *plContext) { |
853 PKIX_PL_Socket *socket, | |
854 void *plContext) | |
855 { | |
856 #ifdef PKIX_SOCKETDEBUG | 810 #ifdef PKIX_SOCKETDEBUG |
857 PRErrorCode errorcode = 0; | 811 PRErrorCode errorcode = 0; |
858 #endif | 812 #endif |
859 PRStatus rv = PR_FAILURE; | 813 PRStatus rv = PR_FAILURE; |
860 PRFileDesc *fileDesc = NULL; | 814 PRFileDesc *fileDesc = NULL; |
861 | 815 |
862 PKIX_ENTER(SOCKET, "pkix_pl_Socket_Shutdown"); | 816 PKIX_ENTER(SOCKET, "pkix_pl_Socket_Shutdown"); |
863 PKIX_NULLCHECK_ONE(socket); | 817 PKIX_NULLCHECK_ONE(socket); |
864 | 818 |
865 fileDesc = | 819 fileDesc = (socket->isServer) ? (socket->serverSock) : (socket->clientSock); |
866 (socket->isServer)?(socket->serverSock):(socket->clientSock); | |
867 | 820 |
868 PKIX_PL_NSSCALLRV(SOCKET, rv, PR_Shutdown, | 821 PKIX_PL_NSSCALLRV(SOCKET, rv, PR_Shutdown, (fileDesc, PR_SHUTDOWN_BOTH)); |
869 (fileDesc, PR_SHUTDOWN_BOTH)); | |
870 | 822 |
871 if (rv == PR_FAILURE) { | 823 if (rv == PR_FAILURE) { |
872 #ifdef PKIX_SOCKETDEBUG | 824 #ifdef PKIX_SOCKETDEBUG |
873 errorcode = PR_GetError(); | 825 errorcode = PR_GetError(); |
874 printf | 826 printf("pkix_pl_Socket_Shutdown: %s\n", |
875 ("pkix_pl_Socket_Shutdown: %s\n", | 827 PR_ErrorToString(errorcode, PR_LANGUAGE_EN)); |
876 PR_ErrorToString(errorcode, PR_LANGUAGE_EN)); | |
877 #endif | 828 #endif |
878 PKIX_ERROR(PKIX_PRSHUTDOWNFAILED); | 829 PKIX_ERROR(PKIX_PRSHUTDOWNFAILED); |
879 } | 830 } |
880 socket->status = SOCKET_SHUTDOWN; | 831 socket->status = SOCKET_SHUTDOWN; |
881 | 832 |
882 cleanup: | 833 cleanup: |
883 | 834 |
884 PKIX_RETURN(SOCKET); | 835 PKIX_RETURN(SOCKET); |
885 } | 836 } |
886 | 837 |
887 /* | 838 /* |
888 * FUNCTION: pkix_pl_Socket_Send | 839 * FUNCTION: pkix_pl_Socket_Send |
889 * DESCRIPTION: | 840 * DESCRIPTION: |
890 * | 841 * |
891 * This functions sends a message using the socket pointed to by "sendSock", | 842 * This functions sends a message using the socket pointed to by "sendSock", |
892 * from the buffer pointed to by "buf", of the number of bytes given by | 843 * from the buffer pointed to by "buf", of the number of bytes given by |
893 * "bytesToWrite", storing the number of bytes actually written at | 844 * "bytesToWrite", storing the number of bytes actually written at |
894 * "pBytesWritten". If "socket" is in non-blocking mode, the send operation | 845 * "pBytesWritten". If "socket" is in non-blocking mode, the send operation |
(...skipping 12 matching lines...) Expand all Loading... |
907 * "pBytesWritten" | 858 * "pBytesWritten" |
908 * The address at which the Int32 value indicating the number of bytes | 859 * The address at which the Int32 value indicating the number of bytes |
909 * actually written is to be stored. Must be non-NULL. | 860 * actually written is to be stored. Must be non-NULL. |
910 * "plContext" | 861 * "plContext" |
911 * Platform-specific context pointer | 862 * Platform-specific context pointer |
912 * THREAD SAFETY: | 863 * THREAD SAFETY: |
913 * Thread Safe (see Thread Safety definitions in Programmer's Guide) | 864 * Thread Safe (see Thread Safety definitions in Programmer's Guide) |
914 * RETURNS: | 865 * RETURNS: |
915 * none | 866 * none |
916 */ | 867 */ |
917 static PKIX_Error * | 868 static PKIX_Error *pkix_pl_Socket_Send(PKIX_PL_Socket *sendSock, void *buf, |
918 pkix_pl_Socket_Send( | 869 PKIX_UInt32 bytesToWrite, |
919 PKIX_PL_Socket *sendSock, | 870 PKIX_Int32 *pBytesWritten, |
920 void *buf, | 871 void *plContext) { |
921 PKIX_UInt32 bytesToWrite, | 872 PRInt32 bytesWritten = 0; |
922 PKIX_Int32 *pBytesWritten, | 873 PRErrorCode errorcode = 0; |
923 void *plContext) | 874 PRFileDesc *fd = NULL; |
924 { | |
925 PRInt32 bytesWritten = 0; | |
926 PRErrorCode errorcode = 0; | |
927 PRFileDesc *fd = NULL; | |
928 | 875 |
929 PKIX_ENTER(SOCKET, "pkix_pl_Socket_Send"); | 876 PKIX_ENTER(SOCKET, "pkix_pl_Socket_Send"); |
930 PKIX_NULLCHECK_TWO(buf, pBytesWritten); | 877 PKIX_NULLCHECK_TWO(buf, pBytesWritten); |
931 | 878 |
932 fd = sendSock->clientSock; | 879 fd = sendSock->clientSock; |
933 | 880 |
934 PKIX_PL_NSSCALLRV(SOCKET, bytesWritten, PR_Send, | 881 PKIX_PL_NSSCALLRV(SOCKET, bytesWritten, PR_Send, |
935 (fd, buf, (PRInt32)bytesToWrite, 0, sendSock->timeout)); | 882 (fd, buf, (PRInt32)bytesToWrite, 0, sendSock->timeout)); |
936 | 883 |
937 if (bytesWritten >= 0) { | 884 if (bytesWritten >= 0) { |
938 if (sendSock->status == SOCKET_SENDRCVPENDING) { | 885 if (sendSock->status == SOCKET_SENDRCVPENDING) { |
939 sendSock->status = SOCKET_RCVPENDING; | 886 sendSock->status = SOCKET_RCVPENDING; |
940 } else { | 887 } else { |
941 sendSock->status = SOCKET_CONNECTED; | 888 sendSock->status = SOCKET_CONNECTED; |
942 } | 889 } |
943 #ifdef PKIX_SOCKETTRACE | 890 #ifdef PKIX_SOCKETTRACE |
944 pkix_pl_socket_tracebuff(buf, bytesWritten); | 891 pkix_pl_socket_tracebuff(buf, bytesWritten); |
945 #endif | 892 #endif |
946 } else { | 893 } else { |
947 errorcode = PR_GetError(); | 894 errorcode = PR_GetError(); |
948 if (errorcode != PR_WOULD_BLOCK_ERROR) { | 895 if (errorcode != PR_WOULD_BLOCK_ERROR) { |
949 #ifdef PKIX_SOCKETDEBUG | 896 #ifdef PKIX_SOCKETDEBUG |
950 printf | 897 printf("pkix_pl_Socket_Send: %s\n", |
951 ("pkix_pl_Socket_Send: %s\n", | 898 PR_ErrorToString(errorcode, PR_LANGUAGE_EN)); |
952 PR_ErrorToString(errorcode, PR_LANGUAGE_EN)); | |
953 #endif | 899 #endif |
954 PKIX_ERROR(PKIX_PRSENDFAILED); | 900 PKIX_ERROR(PKIX_PRSENDFAILED); |
955 } | 901 } |
956 | 902 |
957 sendSock->writeBuf = buf; | 903 sendSock->writeBuf = buf; |
958 sendSock->writeBufSize = bytesToWrite; | 904 sendSock->writeBufSize = bytesToWrite; |
959 if (sendSock->status == SOCKET_RCVPENDING) { | 905 if (sendSock->status == SOCKET_RCVPENDING) { |
960 sendSock->status = SOCKET_SENDRCVPENDING; | 906 sendSock->status = SOCKET_SENDRCVPENDING; |
961 } else { | 907 } else { |
962 sendSock->status = SOCKET_SENDPENDING; | 908 sendSock->status = SOCKET_SENDPENDING; |
963 } | 909 } |
964 } | 910 } |
965 | 911 |
966 *pBytesWritten = (PKIX_Int32)bytesWritten; | 912 *pBytesWritten = (PKIX_Int32)bytesWritten; |
967 | 913 |
968 cleanup: | 914 cleanup: |
969 | 915 |
970 PKIX_RETURN(SOCKET); | 916 PKIX_RETURN(SOCKET); |
971 } | 917 } |
972 | 918 |
973 /* | 919 /* |
974 * FUNCTION: pkix_pl_Socket_Recv | 920 * FUNCTION: pkix_pl_Socket_Recv |
975 * DESCRIPTION: | 921 * DESCRIPTION: |
976 * | 922 * |
977 * This functions receives a message on the socket pointed to by "rcvSock", | 923 * This functions receives a message on the socket pointed to by "rcvSock", |
978 * into the buffer pointed to by "buf", of capacity given by "capacity", | 924 * into the buffer pointed to by "buf", of capacity given by "capacity", |
979 * storing the number of bytes actually received at "pBytesRead". If "socket" | 925 * storing the number of bytes actually received at "pBytesRead". If "socket" |
980 * is in non-blocking mode, the receive operation may store -1 at | 926 * is in non-blocking mode, the receive operation may store -1 at |
(...skipping 14 matching lines...) Expand all Loading... |
995 * "pBytesRead" | 941 * "pBytesRead" |
996 * The address at which is stored the Int32 value of the number of bytes | 942 * The address at which is stored the Int32 value of the number of bytes |
997 * actually received. | 943 * actually received. |
998 * "plContext" | 944 * "plContext" |
999 * Platform-specific context pointer | 945 * Platform-specific context pointer |
1000 * THREAD SAFETY: | 946 * THREAD SAFETY: |
1001 * Thread Safe (see Thread Safety definitions in Programmer's Guide) | 947 * Thread Safe (see Thread Safety definitions in Programmer's Guide) |
1002 * RETURNS: | 948 * RETURNS: |
1003 * none | 949 * none |
1004 */ | 950 */ |
1005 static PKIX_Error * | 951 static PKIX_Error *pkix_pl_Socket_Recv(PKIX_PL_Socket *rcvSock, void *buf, |
1006 pkix_pl_Socket_Recv( | 952 PKIX_UInt32 capacity, |
1007 PKIX_PL_Socket *rcvSock, | 953 PKIX_Int32 *pBytesRead, |
1008 void *buf, | 954 void *plContext) { |
1009 PKIX_UInt32 capacity, | 955 PRErrorCode errorcode = 0; |
1010 PKIX_Int32 *pBytesRead, | 956 PRInt32 bytesRead = 0; |
1011 void *plContext) | 957 PRFileDesc *fd = NULL; |
1012 { | |
1013 PRErrorCode errorcode = 0; | |
1014 PRInt32 bytesRead = 0; | |
1015 PRFileDesc *fd = NULL; | |
1016 | 958 |
1017 PKIX_ENTER(SOCKET, "pkix_pl_Socket_Recv"); | 959 PKIX_ENTER(SOCKET, "pkix_pl_Socket_Recv"); |
1018 PKIX_NULLCHECK_THREE(rcvSock, buf, pBytesRead); | 960 PKIX_NULLCHECK_THREE(rcvSock, buf, pBytesRead); |
1019 | 961 |
1020 fd = rcvSock->clientSock; | 962 fd = rcvSock->clientSock; |
1021 | 963 |
1022 PKIX_PL_NSSCALLRV(SOCKET, bytesRead, PR_Recv, | 964 PKIX_PL_NSSCALLRV(SOCKET, bytesRead, PR_Recv, |
1023 (fd, buf, (PRInt32)capacity, 0, rcvSock->timeout)); | 965 (fd, buf, (PRInt32)capacity, 0, rcvSock->timeout)); |
1024 | 966 |
1025 if (bytesRead > 0) { | 967 if (bytesRead > 0) { |
1026 if (rcvSock->status == SOCKET_SENDRCVPENDING) { | 968 if (rcvSock->status == SOCKET_SENDRCVPENDING) { |
1027 rcvSock->status = SOCKET_SENDPENDING; | 969 rcvSock->status = SOCKET_SENDPENDING; |
1028 } else { | 970 } else { |
1029 rcvSock->status = SOCKET_CONNECTED; | 971 rcvSock->status = SOCKET_CONNECTED; |
1030 } | 972 } |
1031 #ifdef PKIX_SOCKETTRACE | 973 #ifdef PKIX_SOCKETTRACE |
1032 pkix_pl_socket_tracebuff(buf, bytesRead); | 974 pkix_pl_socket_tracebuff(buf, bytesRead); |
1033 #endif | 975 #endif |
1034 } else if (bytesRead == 0) { | 976 } else if (bytesRead == 0) { |
1035 PKIX_ERROR(PKIX_PRRECVREPORTSNETWORKCONNECTIONCLOSED); | 977 PKIX_ERROR(PKIX_PRRECVREPORTSNETWORKCONNECTIONCLOSED); |
1036 } else { | 978 } else { |
1037 errorcode = PR_GetError(); | 979 errorcode = PR_GetError(); |
1038 if (errorcode != PR_WOULD_BLOCK_ERROR) { | 980 if (errorcode != PR_WOULD_BLOCK_ERROR) { |
1039 #ifdef PKIX_SOCKETDEBUG | 981 #ifdef PKIX_SOCKETDEBUG |
1040 printf | 982 printf("pkix_pl_Socket_Recv: %s\n", |
1041 ("pkix_pl_Socket_Recv: %s\n", | 983 PR_ErrorToString(errorcode, PR_LANGUAGE_EN)); |
1042 PR_ErrorToString(errorcode, PR_LANGUAGE_EN)); | |
1043 #endif | 984 #endif |
1044 PKIX_ERROR(PKIX_PRRECVFAILED); | 985 PKIX_ERROR(PKIX_PRRECVFAILED); |
1045 } | 986 } |
1046 rcvSock->readBuf = buf; | 987 rcvSock->readBuf = buf; |
1047 rcvSock->readBufSize = capacity; | 988 rcvSock->readBufSize = capacity; |
1048 if (rcvSock->status == SOCKET_SENDPENDING) { | 989 if (rcvSock->status == SOCKET_SENDPENDING) { |
1049 rcvSock->status = SOCKET_SENDRCVPENDING; | 990 rcvSock->status = SOCKET_SENDRCVPENDING; |
1050 } else { | 991 } else { |
1051 rcvSock->status = SOCKET_RCVPENDING; | 992 rcvSock->status = SOCKET_RCVPENDING; |
1052 } | 993 } |
| 994 } |
1053 | 995 |
1054 } | 996 *pBytesRead = (PKIX_Int32)bytesRead; |
1055 | |
1056 *pBytesRead = (PKIX_Int32)bytesRead; | |
1057 | 997 |
1058 cleanup: | 998 cleanup: |
1059 | 999 |
1060 PKIX_RETURN(SOCKET); | 1000 PKIX_RETURN(SOCKET); |
1061 } | 1001 } |
1062 | 1002 |
1063 /* | 1003 /* |
1064 * FUNCTION: pkix_pl_Socket_Poll | 1004 * FUNCTION: pkix_pl_Socket_Poll |
1065 * DESCRIPTION: | 1005 * DESCRIPTION: |
1066 * | 1006 * |
1067 * This functions checks for completion of an earlier Send or Recv on the | 1007 * This functions checks for completion of an earlier Send or Recv on the |
1068 * socket pointed to by "sock", storing in "pBytesWritten" the number of bytes | 1008 * socket pointed to by "sock", storing in "pBytesWritten" the number of bytes |
1069 * written by a completed Send and in "pBytesRead" the number of bytes | 1009 * written by a completed Send and in "pBytesRead" the number of bytes |
1070 * received in a completed Recv. A value of -1 returned indicates the | 1010 * received in a completed Recv. A value of -1 returned indicates the |
(...skipping 10 matching lines...) Expand all Loading... |
1081 * "pBytesRead" | 1021 * "pBytesRead" |
1082 * The address at which the number of bytes read is to be stored, if | 1022 * The address at which the number of bytes read is to be stored, if |
1083 * a pending Recv has completed. If NULL, Recvs are not checked. | 1023 * a pending Recv has completed. If NULL, Recvs are not checked. |
1084 * "plContext" | 1024 * "plContext" |
1085 * Platform-specific context pointer | 1025 * Platform-specific context pointer |
1086 * THREAD SAFETY: | 1026 * THREAD SAFETY: |
1087 * Thread Safe (see Thread Safety definitions in Programmer's Guide) | 1027 * Thread Safe (see Thread Safety definitions in Programmer's Guide) |
1088 * RETURNS: | 1028 * RETURNS: |
1089 * none | 1029 * none |
1090 */ | 1030 */ |
1091 static PKIX_Error * | 1031 static PKIX_Error *pkix_pl_Socket_Poll(PKIX_PL_Socket *sock, |
1092 pkix_pl_Socket_Poll( | 1032 PKIX_Int32 *pBytesWritten, |
1093 PKIX_PL_Socket *sock, | 1033 PKIX_Int32 *pBytesRead, |
1094 PKIX_Int32 *pBytesWritten, | 1034 void *plContext) { |
1095 PKIX_Int32 *pBytesRead, | 1035 PRPollDesc pollDesc; |
1096 void *plContext) | 1036 PRInt32 numEvents = 0; |
1097 { | 1037 PKIX_Int32 bytesRead = 0; |
1098 PRPollDesc pollDesc; | 1038 PKIX_Int32 bytesWritten = 0; |
1099 PRInt32 numEvents = 0; | 1039 PRErrorCode errorcode = 0; |
1100 PKIX_Int32 bytesRead = 0; | |
1101 PKIX_Int32 bytesWritten = 0; | |
1102 PRErrorCode errorcode = 0; | |
1103 | 1040 |
1104 PKIX_ENTER(SOCKET, "pkix_pl_Socket_Poll"); | 1041 PKIX_ENTER(SOCKET, "pkix_pl_Socket_Poll"); |
1105 PKIX_NULLCHECK_ONE(sock); | 1042 PKIX_NULLCHECK_ONE(sock); |
1106 | 1043 |
1107 pollDesc.fd = sock->clientSock; | 1044 pollDesc.fd = sock->clientSock; |
1108 pollDesc.in_flags = 0; | 1045 pollDesc.in_flags = 0; |
1109 pollDesc.out_flags = 0; | 1046 pollDesc.out_flags = 0; |
1110 | 1047 |
1111 if ((pBytesWritten) && | 1048 if ((pBytesWritten) && ((sock->status == SOCKET_SENDPENDING) || |
1112 ((sock->status == SOCKET_SENDPENDING) || | 1049 (sock->status == SOCKET_SENDRCVPENDING))) { |
1113 (sock->status == SOCKET_SENDRCVPENDING))) { | 1050 pollDesc.in_flags = PR_POLL_WRITE; |
1114 pollDesc.in_flags = PR_POLL_WRITE; | 1051 } |
1115 } | |
1116 | 1052 |
1117 if ((pBytesRead) && | 1053 if ((pBytesRead) && ((sock->status == SOCKET_RCVPENDING) || |
1118 ((sock->status == SOCKET_RCVPENDING) || | 1054 (sock->status == SOCKET_SENDRCVPENDING))) { |
1119 (sock->status == SOCKET_SENDRCVPENDING))) { | 1055 pollDesc.in_flags |= PR_POLL_READ; |
1120 pollDesc.in_flags |= PR_POLL_READ; | 1056 } |
1121 } | |
1122 | 1057 |
1123 PKIX_PL_NSSCALLRV(SOCKET, numEvents, PR_Poll, (&pollDesc, 1, 0)); | 1058 PKIX_PL_NSSCALLRV(SOCKET, numEvents, PR_Poll, (&pollDesc, 1, 0)); |
1124 | 1059 |
1125 if (numEvents < 0) { | 1060 if (numEvents < 0) { |
1126 PKIX_ERROR(PKIX_PRPOLLFAILED); | 1061 PKIX_ERROR(PKIX_PRPOLLFAILED); |
1127 } else if (numEvents > 0) { | 1062 } else if (numEvents > 0) { |
1128 if (pollDesc.out_flags & PR_POLL_WRITE) { | 1063 if (pollDesc.out_flags & PR_POLL_WRITE) { |
1129 PKIX_CHECK(pkix_pl_Socket_Send | 1064 PKIX_CHECK(pkix_pl_Socket_Send(sock, sock->writeBuf, sock->writeBufSize, |
1130 (sock, | 1065 &bytesWritten, plContext), |
1131 sock->writeBuf, | 1066 PKIX_SOCKETSENDFAILED); |
1132 sock->writeBufSize, | 1067 *pBytesWritten = (PKIX_Int32)bytesWritten; |
1133 &bytesWritten, | 1068 if (bytesWritten >= 0) { |
1134 plContext), | 1069 sock->writeBuf = NULL; |
1135 PKIX_SOCKETSENDFAILED); | 1070 sock->writeBufSize = 0; |
1136 *pBytesWritten = (PKIX_Int32)bytesWritten; | 1071 } |
1137 if (bytesWritten >= 0) { | 1072 } |
1138 sock->writeBuf = NULL; | |
1139 sock->writeBufSize = 0; | |
1140 } | |
1141 } | |
1142 | 1073 |
1143 if (pollDesc.out_flags & PR_POLL_READ) { | 1074 if (pollDesc.out_flags & PR_POLL_READ) { |
1144 PKIX_CHECK(pkix_pl_Socket_Recv | 1075 PKIX_CHECK(pkix_pl_Socket_Recv(sock, sock->readBuf, sock->readBufSize, |
1145 (sock, | 1076 &bytesRead, plContext), |
1146 sock->readBuf, | 1077 PKIX_SOCKETRECVFAILED); |
1147 sock->readBufSize, | 1078 *pBytesRead = (PKIX_Int32)bytesRead; |
1148 &bytesRead, | 1079 if (bytesRead >= 0) { |
1149 plContext), | 1080 sock->readBuf = NULL; |
1150 PKIX_SOCKETRECVFAILED); | 1081 sock->readBufSize = 0; |
1151 *pBytesRead = (PKIX_Int32)bytesRead; | 1082 } |
1152 if (bytesRead >= 0) { | 1083 } |
1153 sock->readBuf = NULL; | 1084 } else if (numEvents == 0) { |
1154 sock->readBufSize = 0; | 1085 errorcode = PR_GetError(); |
1155 } | 1086 if (errorcode != PR_WOULD_BLOCK_ERROR) { |
1156 } | |
1157 } else if (numEvents == 0) { | |
1158 errorcode = PR_GetError(); | |
1159 if (errorcode != PR_WOULD_BLOCK_ERROR) { | |
1160 #ifdef PKIX_SOCKETDEBUG | 1087 #ifdef PKIX_SOCKETDEBUG |
1161 printf | 1088 printf("pkix_pl_Socket_Poll: %s\n", |
1162 ("pkix_pl_Socket_Poll: %s\n", | 1089 PR_ErrorToString(errorcode, PR_LANGUAGE_EN)); |
1163 PR_ErrorToString(errorcode, PR_LANGUAGE_EN)); | |
1164 #endif | 1090 #endif |
1165 PKIX_ERROR(PKIX_PRPOLLFAILED); | 1091 PKIX_ERROR(PKIX_PRPOLLFAILED); |
1166 } | 1092 } |
1167 if (pBytesWritten) { | 1093 if (pBytesWritten) { |
1168 *pBytesWritten = 0; | 1094 *pBytesWritten = 0; |
1169 } | 1095 } |
1170 if (pBytesRead) { | 1096 if (pBytesRead) { |
1171 *pBytesRead = 0; | 1097 *pBytesRead = 0; |
1172 } | 1098 } |
1173 } | 1099 } |
1174 | 1100 |
1175 cleanup: | 1101 cleanup: |
1176 | 1102 |
1177 PKIX_RETURN(SOCKET); | 1103 PKIX_RETURN(SOCKET); |
1178 } | 1104 } |
1179 | 1105 |
1180 /* | 1106 /* |
1181 * FUNCTION: pkix_pl_Socket_Accept | 1107 * FUNCTION: pkix_pl_Socket_Accept |
1182 * DESCRIPTION: | 1108 * DESCRIPTION: |
1183 * | 1109 * |
1184 * This functions accepts a client connection for the server Socket pointed | 1110 * This functions accepts a client connection for the server Socket pointed |
1185 * to by "serverSocket", creating a new Socket and storing the result at | 1111 * to by "serverSocket", creating a new Socket and storing the result at |
1186 * "pRendezvousSocket". If "serverSocket" is in non-blocking mode, this | 1112 * "pRendezvousSocket". If "serverSocket" is in non-blocking mode, this |
1187 * function will return NULL if there is no client connection to accept. | 1113 * function will return NULL if there is no client connection to accept. |
1188 * Otherwise this function will block until a connection is available. | 1114 * Otherwise this function will block until a connection is available. |
1189 * When a client connection is available the new Socket will have the same | 1115 * When a client connection is available the new Socket will have the same |
1190 * blocking/non-blocking property as "serverSocket". | 1116 * blocking/non-blocking property as "serverSocket". |
1191 * | 1117 * |
1192 * PARAMETERS: | 1118 * PARAMETERS: |
1193 * "serverSocket" | 1119 * "serverSocket" |
1194 * The address of the Socket for which a client connection is to be | 1120 * The address of the Socket for which a client connection is to be |
1195 * accepted. Must be non-NULL. | 1121 * accepted. Must be non-NULL. |
1196 * "pRendezvousSocket" | 1122 * "pRendezvousSocket" |
1197 * The address at which the created Socket is stored, when a client | 1123 * The address at which the created Socket is stored, when a client |
1198 * connection is available, or at which NULL is stored, if no connection | 1124 * connection is available, or at which NULL is stored, if no connection |
1199 * is available for a non-blocking "serverSocket". Must be non-NULL. | 1125 * is available for a non-blocking "serverSocket". Must be non-NULL. |
1200 * "plContext" | 1126 * "plContext" |
1201 * Platform-specific context pointer | 1127 * Platform-specific context pointer |
1202 * THREAD SAFETY: | 1128 * THREAD SAFETY: |
1203 * Thread Safe (see Thread Safety definitions in Programmer's Guide) | 1129 * Thread Safe (see Thread Safety definitions in Programmer's Guide) |
1204 * RETURNS: | 1130 * RETURNS: |
1205 * none | 1131 * none |
1206 */ | 1132 */ |
1207 static PKIX_Error * | 1133 static PKIX_Error *pkix_pl_Socket_Accept(PKIX_PL_Socket *serverSocket, |
1208 pkix_pl_Socket_Accept( | 1134 PKIX_PL_Socket **pRendezvousSocket, |
1209 PKIX_PL_Socket *serverSocket, | 1135 void *plContext) { |
1210 PKIX_PL_Socket **pRendezvousSocket, | 1136 PRErrorCode errorcode = 0; |
1211 void *plContext) | 1137 PRFileDesc *rendezvousSock = NULL; |
1212 { | 1138 PRNetAddr *clientAddr = NULL; |
1213 PRErrorCode errorcode = 0; | 1139 PKIX_PL_Socket *newSocket = NULL; |
1214 PRFileDesc *rendezvousSock = NULL; | |
1215 PRNetAddr *clientAddr = NULL; | |
1216 PKIX_PL_Socket *newSocket = NULL; | |
1217 | 1140 |
1218 PKIX_ENTER(SOCKET, "pkix_pl_Socket_Accept"); | 1141 PKIX_ENTER(SOCKET, "pkix_pl_Socket_Accept"); |
1219 PKIX_NULLCHECK_TWO(serverSocket, pRendezvousSocket); | 1142 PKIX_NULLCHECK_TWO(serverSocket, pRendezvousSocket); |
1220 | 1143 |
1221 PKIX_PL_NSSCALLRV(SOCKET, rendezvousSock, PR_Accept, | 1144 PKIX_PL_NSSCALLRV( |
1222 (serverSocket->serverSock, clientAddr, serverSocket->timeout)); | 1145 SOCKET, rendezvousSock, PR_Accept, |
| 1146 (serverSocket->serverSock, clientAddr, serverSocket->timeout)); |
1223 | 1147 |
1224 if (!rendezvousSock) { | 1148 if (!rendezvousSock) { |
1225 errorcode = PR_GetError(); | 1149 errorcode = PR_GetError(); |
1226 if (errorcode != PR_WOULD_BLOCK_ERROR) { | 1150 if (errorcode != PR_WOULD_BLOCK_ERROR) { |
1227 #ifdef PKIX_SOCKETDEBUG | 1151 #ifdef PKIX_SOCKETDEBUG |
1228 printf | 1152 printf("pkix_pl_Socket_Accept: %s\n", |
1229 ("pkix_pl_Socket_Accept: %s\n", | 1153 PR_ErrorToString(errorcode, PR_LANGUAGE_EN)); |
1230 PR_ErrorToString(errorcode, PR_LANGUAGE_EN)); | |
1231 #endif | 1154 #endif |
1232 PKIX_ERROR(PKIX_PRACCEPTFAILED); | 1155 PKIX_ERROR(PKIX_PRACCEPTFAILED); |
1233 } | 1156 } |
1234 serverSocket->status = SOCKET_ACCEPTPENDING; | 1157 serverSocket->status = SOCKET_ACCEPTPENDING; |
1235 *pRendezvousSocket = NULL; | 1158 *pRendezvousSocket = NULL; |
1236 goto cleanup; | 1159 goto cleanup; |
1237 | 1160 } |
1238 } | |
1239 | 1161 |
1240 #ifdef PKIX_SOCKETDEBUG | 1162 #ifdef PKIX_SOCKETDEBUG |
1241 printf("Successful accept!\n"); | 1163 printf("Successful accept!\n"); |
1242 #endif | 1164 #endif |
1243 | 1165 |
1244 PKIX_CHECK(PKIX_PL_Object_Alloc | 1166 PKIX_CHECK(PKIX_PL_Object_Alloc(PKIX_SOCKET_TYPE, sizeof(PKIX_PL_Socket), |
1245 (PKIX_SOCKET_TYPE, | 1167 (PKIX_PL_Object **)&newSocket, plContext), |
1246 sizeof (PKIX_PL_Socket), | 1168 PKIX_COULDNOTCREATESOCKETOBJECT); |
1247 (PKIX_PL_Object **)&newSocket, | |
1248 plContext), | |
1249 PKIX_COULDNOTCREATESOCKETOBJECT); | |
1250 | 1169 |
1251 newSocket->isServer = PKIX_FALSE; | 1170 newSocket->isServer = PKIX_FALSE; |
1252 newSocket->timeout = serverSocket->timeout; | 1171 newSocket->timeout = serverSocket->timeout; |
1253 newSocket->clientSock = rendezvousSock; | 1172 newSocket->clientSock = rendezvousSock; |
1254 newSocket->serverSock = NULL; | 1173 newSocket->serverSock = NULL; |
1255 newSocket->netAddr = NULL; | 1174 newSocket->netAddr = NULL; |
1256 newSocket->status = SOCKET_CONNECTED; | 1175 newSocket->status = SOCKET_CONNECTED; |
1257 newSocket->callbackList.shutdownCallback = pkix_pl_Socket_Shutdown; | 1176 newSocket->callbackList.shutdownCallback = pkix_pl_Socket_Shutdown; |
1258 newSocket->callbackList.listenCallback = pkix_pl_Socket_Listen; | 1177 newSocket->callbackList.listenCallback = pkix_pl_Socket_Listen; |
1259 newSocket->callbackList.acceptCallback = pkix_pl_Socket_Accept; | 1178 newSocket->callbackList.acceptCallback = pkix_pl_Socket_Accept; |
1260 newSocket->callbackList.connectcontinueCallback = | 1179 newSocket->callbackList.connectcontinueCallback = |
1261 pkix_pl_Socket_ConnectContinue; | 1180 pkix_pl_Socket_ConnectContinue; |
1262 newSocket->callbackList.sendCallback = pkix_pl_Socket_Send; | 1181 newSocket->callbackList.sendCallback = pkix_pl_Socket_Send; |
1263 newSocket->callbackList.recvCallback = pkix_pl_Socket_Recv; | 1182 newSocket->callbackList.recvCallback = pkix_pl_Socket_Recv; |
1264 newSocket->callbackList.pollCallback = pkix_pl_Socket_Poll; | 1183 newSocket->callbackList.pollCallback = pkix_pl_Socket_Poll; |
1265 | 1184 |
1266 if (serverSocket->timeout == 0) { | 1185 if (serverSocket->timeout == 0) { |
1267 PKIX_CHECK(pkix_pl_Socket_SetNonBlocking | 1186 PKIX_CHECK(pkix_pl_Socket_SetNonBlocking(rendezvousSock, plContext), |
1268 (rendezvousSock, plContext), | 1187 PKIX_SOCKETSETNONBLOCKINGFAILED); |
1269 PKIX_SOCKETSETNONBLOCKINGFAILED); | 1188 } |
1270 } | |
1271 | 1189 |
1272 *pRendezvousSocket = newSocket; | 1190 *pRendezvousSocket = newSocket; |
1273 | 1191 |
1274 cleanup: | 1192 cleanup: |
1275 | 1193 |
1276 PKIX_RETURN(SOCKET); | 1194 PKIX_RETURN(SOCKET); |
1277 } | 1195 } |
1278 | 1196 |
1279 /* | 1197 /* |
1280 * FUNCTION: pkix_pl_Socket_Create | 1198 * FUNCTION: pkix_pl_Socket_Create |
1281 * DESCRIPTION: | 1199 * DESCRIPTION: |
1282 * | 1200 * |
1283 * This function creates a new Socket, setting it to be a server or a client | 1201 * This function creates a new Socket, setting it to be a server or a client |
1284 * according to the value of "isServer", setting its timeout value from | 1202 * according to the value of "isServer", setting its timeout value from |
1285 * "timeout" and server address from "netAddr", and stores the created Socket | 1203 * "timeout" and server address from "netAddr", and stores the created Socket |
1286 * at "pSocket". | 1204 * at "pSocket". |
(...skipping 14 matching lines...) Expand all Loading... |
1301 * "plContext" | 1219 * "plContext" |
1302 * Platform-specific context pointer. | 1220 * Platform-specific context pointer. |
1303 * THREAD SAFETY: | 1221 * THREAD SAFETY: |
1304 * Thread Safe (see Thread Safety Definitions in Programmer's Guide) | 1222 * Thread Safe (see Thread Safety Definitions in Programmer's Guide) |
1305 * RETURNS: | 1223 * RETURNS: |
1306 * Returns NULL if the function succeeds. | 1224 * Returns NULL if the function succeeds. |
1307 * Returns a Socket Error if the function fails in | 1225 * Returns a Socket Error if the function fails in |
1308 * a non-fatal way. | 1226 * a non-fatal way. |
1309 * Returns a Fatal Error if the function fails in an unrecoverable way. | 1227 * Returns a Fatal Error if the function fails in an unrecoverable way. |
1310 */ | 1228 */ |
1311 PKIX_Error * | 1229 PKIX_Error *pkix_pl_Socket_Create(PKIX_Boolean isServer, PRIntervalTime timeout, |
1312 pkix_pl_Socket_Create( | 1230 PRNetAddr *netAddr, PRErrorCode *status, |
1313 PKIX_Boolean isServer, | 1231 PKIX_PL_Socket **pSocket, void *plContext) { |
1314 PRIntervalTime timeout, | 1232 PKIX_PL_Socket *socket = NULL; |
1315 PRNetAddr *netAddr, | |
1316 PRErrorCode *status, | |
1317 PKIX_PL_Socket **pSocket, | |
1318 void *plContext) | |
1319 { | |
1320 PKIX_PL_Socket *socket = NULL; | |
1321 | 1233 |
1322 PKIX_ENTER(SOCKET, "pkix_pl_Socket_Create"); | 1234 PKIX_ENTER(SOCKET, "pkix_pl_Socket_Create"); |
1323 PKIX_NULLCHECK_ONE(pSocket); | 1235 PKIX_NULLCHECK_ONE(pSocket); |
1324 | 1236 |
1325 PKIX_CHECK(PKIX_PL_Object_Alloc | 1237 PKIX_CHECK(PKIX_PL_Object_Alloc(PKIX_SOCKET_TYPE, sizeof(PKIX_PL_Socket), |
1326 (PKIX_SOCKET_TYPE, | 1238 (PKIX_PL_Object **)&socket, plContext), |
1327 sizeof (PKIX_PL_Socket), | 1239 PKIX_COULDNOTCREATESOCKETOBJECT); |
1328 (PKIX_PL_Object **)&socket, | |
1329 plContext), | |
1330 PKIX_COULDNOTCREATESOCKETOBJECT); | |
1331 | 1240 |
1332 socket->isServer = isServer; | 1241 socket->isServer = isServer; |
1333 socket->timeout = timeout; | 1242 socket->timeout = timeout; |
1334 socket->clientSock = NULL; | 1243 socket->clientSock = NULL; |
1335 socket->serverSock = NULL; | 1244 socket->serverSock = NULL; |
1336 socket->netAddr = netAddr; | 1245 socket->netAddr = netAddr; |
1337 | 1246 |
1338 socket->callbackList.listenCallback = pkix_pl_Socket_Listen; | 1247 socket->callbackList.listenCallback = pkix_pl_Socket_Listen; |
1339 socket->callbackList.acceptCallback = pkix_pl_Socket_Accept; | 1248 socket->callbackList.acceptCallback = pkix_pl_Socket_Accept; |
1340 socket->callbackList.connectcontinueCallback = | 1249 socket->callbackList.connectcontinueCallback = pkix_pl_Socket_ConnectContinue; |
1341 pkix_pl_Socket_ConnectContinue; | 1250 socket->callbackList.sendCallback = pkix_pl_Socket_Send; |
1342 socket->callbackList.sendCallback = pkix_pl_Socket_Send; | 1251 socket->callbackList.recvCallback = pkix_pl_Socket_Recv; |
1343 socket->callbackList.recvCallback = pkix_pl_Socket_Recv; | 1252 socket->callbackList.pollCallback = pkix_pl_Socket_Poll; |
1344 socket->callbackList.pollCallback = pkix_pl_Socket_Poll; | 1253 socket->callbackList.shutdownCallback = pkix_pl_Socket_Shutdown; |
1345 socket->callbackList.shutdownCallback = pkix_pl_Socket_Shutdown; | |
1346 | 1254 |
1347 if (isServer) { | 1255 if (isServer) { |
1348 PKIX_CHECK(pkix_pl_Socket_CreateServer(socket, plContext), | 1256 PKIX_CHECK(pkix_pl_Socket_CreateServer(socket, plContext), |
1349 PKIX_SOCKETCREATESERVERFAILED); | 1257 PKIX_SOCKETCREATESERVERFAILED); |
1350 *status = 0; | 1258 *status = 0; |
1351 } else { | 1259 } else { |
1352 socket->timeout = timeout; | 1260 socket->timeout = timeout; |
1353 PKIX_CHECK(pkix_pl_Socket_CreateClient(socket, plContext), | 1261 PKIX_CHECK(pkix_pl_Socket_CreateClient(socket, plContext), |
1354 PKIX_SOCKETCREATECLIENTFAILED); | 1262 PKIX_SOCKETCREATECLIENTFAILED); |
1355 PKIX_CHECK(pkix_pl_Socket_Connect(socket, status, plContext), | 1263 PKIX_CHECK(pkix_pl_Socket_Connect(socket, status, plContext), |
1356 PKIX_SOCKETCONNECTFAILED); | 1264 PKIX_SOCKETCONNECTFAILED); |
1357 } | 1265 } |
1358 | 1266 |
1359 *pSocket = socket; | 1267 *pSocket = socket; |
1360 | 1268 |
1361 cleanup: | 1269 cleanup: |
1362 if (PKIX_ERROR_RECEIVED) { | 1270 if (PKIX_ERROR_RECEIVED) { |
1363 PKIX_DECREF(socket); | 1271 PKIX_DECREF(socket); |
1364 } | 1272 } |
1365 | 1273 |
1366 PKIX_RETURN(SOCKET); | 1274 PKIX_RETURN(SOCKET); |
1367 } | 1275 } |
1368 | 1276 |
1369 /* | 1277 /* |
1370 * FUNCTION: pkix_pl_Socket_CreateByName | 1278 * FUNCTION: pkix_pl_Socket_CreateByName |
1371 * DESCRIPTION: | 1279 * DESCRIPTION: |
1372 * | 1280 * |
1373 * This function creates a new Socket, setting it to be a server or a client | 1281 * This function creates a new Socket, setting it to be a server or a client |
1374 * according to the value of "isServer", setting its timeout value from | 1282 * according to the value of "isServer", setting its timeout value from |
1375 * "timeout" and server address and port number from "serverName", and stores | 1283 * "timeout" and server address and port number from "serverName", and stores |
1376 * the status at "pStatus" and the created Socket at "pSocket". | 1284 * the status at "pStatus" and the created Socket at "pSocket". |
(...skipping 20 matching lines...) Expand all Loading... |
1397 * "plContext" | 1305 * "plContext" |
1398 * Platform-specific context pointer. | 1306 * Platform-specific context pointer. |
1399 * THREAD SAFETY: | 1307 * THREAD SAFETY: |
1400 * Thread Safe (see Thread Safety Definitions in Programmer's Guide) | 1308 * Thread Safe (see Thread Safety Definitions in Programmer's Guide) |
1401 * RETURNS: | 1309 * RETURNS: |
1402 * Returns NULL if the function succeeds. | 1310 * Returns NULL if the function succeeds. |
1403 * Returns a Socket Error if the function fails in | 1311 * Returns a Socket Error if the function fails in |
1404 * a non-fatal way. | 1312 * a non-fatal way. |
1405 * Returns a Fatal Error if the function fails in an unrecoverable way. | 1313 * Returns a Fatal Error if the function fails in an unrecoverable way. |
1406 */ | 1314 */ |
1407 PKIX_Error * | 1315 PKIX_Error *pkix_pl_Socket_CreateByName(PKIX_Boolean isServer, |
1408 pkix_pl_Socket_CreateByName( | 1316 PRIntervalTime timeout, |
1409 PKIX_Boolean isServer, | 1317 char *serverName, PRErrorCode *pStatus, |
1410 PRIntervalTime timeout, | 1318 PKIX_PL_Socket **pSocket, |
1411 char *serverName, | 1319 void *plContext) { |
1412 PRErrorCode *pStatus, | 1320 PRNetAddr netAddr; |
1413 PKIX_PL_Socket **pSocket, | 1321 PKIX_PL_Socket *socket = NULL; |
1414 void *plContext) | 1322 char *sepPtr = NULL; |
1415 { | 1323 PRHostEnt hostent; |
1416 PRNetAddr netAddr; | 1324 PRIntn hostenum; |
1417 PKIX_PL_Socket *socket = NULL; | 1325 PRStatus prstatus = PR_FAILURE; |
1418 char *sepPtr = NULL; | 1326 char buf[PR_NETDB_BUF_SIZE]; |
1419 PRHostEnt hostent; | 1327 PRUint16 portNum = 0; |
1420 PRIntn hostenum; | 1328 char *localCopyName = NULL; |
1421 PRStatus prstatus = PR_FAILURE; | |
1422 char buf[PR_NETDB_BUF_SIZE]; | |
1423 PRUint16 portNum = 0; | |
1424 char *localCopyName = NULL; | |
1425 | 1329 |
1426 PKIX_ENTER(SOCKET, "pkix_pl_Socket_CreateByName"); | 1330 PKIX_ENTER(SOCKET, "pkix_pl_Socket_CreateByName"); |
1427 PKIX_NULLCHECK_TWO(serverName, pSocket); | 1331 PKIX_NULLCHECK_TWO(serverName, pSocket); |
1428 | 1332 |
1429 localCopyName = PL_strdup(serverName); | 1333 localCopyName = PL_strdup(serverName); |
1430 | 1334 |
1431 sepPtr = strchr(localCopyName, ':'); | 1335 sepPtr = strchr(localCopyName, ':'); |
1432 /* First strip off the portnum, if present, from the end of the name */ | 1336 /* First strip off the portnum, if present, from the end of the name */ |
1433 if (sepPtr) { | 1337 if (sepPtr) { |
1434 *sepPtr++ = '\0'; | 1338 *sepPtr++ = '\0'; |
1435 portNum = (PRUint16)atoi(sepPtr); | 1339 portNum = (PRUint16)atoi(sepPtr); |
1436 } else { | 1340 } else { |
1437 portNum = (PRUint16)LDAP_PORT; | 1341 portNum = (PRUint16)LDAP_PORT; |
1438 } | 1342 } |
1439 | 1343 |
1440 prstatus = PR_GetHostByName(localCopyName, buf, sizeof(buf), &hostent); | 1344 prstatus = PR_GetHostByName(localCopyName, buf, sizeof(buf), &hostent); |
1441 | 1345 |
1442 if ((prstatus != PR_SUCCESS) || (hostent.h_length != 4)) { | 1346 if ((prstatus != PR_SUCCESS) || (hostent.h_length != 4)) { |
1443 /* | 1347 /* |
1444 * The hostname may be a fully-qualified name. Try using just | 1348 * The hostname may be a fully-qualified name. Try using just |
1445 * the leftmost component in our lookup. | 1349 * the leftmost component in our lookup. |
1446 */ | 1350 */ |
1447 sepPtr = strchr(localCopyName, '.'); | 1351 sepPtr = strchr(localCopyName, '.'); |
1448 if (sepPtr) { | 1352 if (sepPtr) { |
1449 *sepPtr++ = '\0'; | 1353 *sepPtr++ = '\0'; |
1450 } | 1354 } |
1451 prstatus = PR_GetHostByName | 1355 prstatus = PR_GetHostByName(localCopyName, buf, sizeof(buf), &hostent); |
1452 (localCopyName, buf, sizeof(buf), &hostent); | |
1453 | 1356 |
1454 if ((prstatus != PR_SUCCESS) || (hostent.h_length != 4)) { | 1357 if ((prstatus != PR_SUCCESS) || (hostent.h_length != 4)) { |
1455 PKIX_ERROR | 1358 PKIX_ERROR(PKIX_PRGETHOSTBYNAMEREJECTSHOSTNAMEARGUMENT); |
1456 (PKIX_PRGETHOSTBYNAMEREJECTSHOSTNAMEARGUMENT); | 1359 } |
1457 } | 1360 } |
1458 } | |
1459 | 1361 |
1460 netAddr.inet.family = PR_AF_INET; | 1362 netAddr.inet.family = PR_AF_INET; |
1461 netAddr.inet.port = PR_htons(portNum); | 1363 netAddr.inet.port = PR_htons(portNum); |
1462 | 1364 |
1463 if (isServer) { | 1365 if (isServer) { |
1464 | 1366 |
1465 netAddr.inet.ip = PR_INADDR_ANY; | 1367 netAddr.inet.ip = PR_INADDR_ANY; |
1466 | 1368 |
1467 } else { | 1369 } else { |
1468 | 1370 |
1469 hostenum = PR_EnumerateHostEnt(0, &hostent, portNum, &netAddr); | 1371 hostenum = PR_EnumerateHostEnt(0, &hostent, portNum, &netAddr); |
1470 if (hostenum == -1) { | 1372 if (hostenum == -1) { |
1471 PKIX_ERROR(PKIX_PRENUMERATEHOSTENTFAILED); | 1373 PKIX_ERROR(PKIX_PRENUMERATEHOSTENTFAILED); |
1472 } | 1374 } |
1473 } | 1375 } |
1474 | 1376 |
1475 PKIX_CHECK(PKIX_PL_Object_Alloc | 1377 PKIX_CHECK(PKIX_PL_Object_Alloc(PKIX_SOCKET_TYPE, sizeof(PKIX_PL_Socket), |
1476 (PKIX_SOCKET_TYPE, | 1378 (PKIX_PL_Object **)&socket, plContext), |
1477 sizeof (PKIX_PL_Socket), | 1379 PKIX_COULDNOTCREATESOCKETOBJECT); |
1478 (PKIX_PL_Object **)&socket, | |
1479 plContext), | |
1480 PKIX_COULDNOTCREATESOCKETOBJECT); | |
1481 | 1380 |
1482 socket->isServer = isServer; | 1381 socket->isServer = isServer; |
1483 socket->timeout = timeout; | 1382 socket->timeout = timeout; |
1484 socket->clientSock = NULL; | 1383 socket->clientSock = NULL; |
1485 socket->serverSock = NULL; | 1384 socket->serverSock = NULL; |
1486 socket->netAddr = &netAddr; | 1385 socket->netAddr = &netAddr; |
1487 | 1386 |
1488 socket->callbackList.listenCallback = pkix_pl_Socket_Listen; | 1387 socket->callbackList.listenCallback = pkix_pl_Socket_Listen; |
1489 socket->callbackList.acceptCallback = pkix_pl_Socket_Accept; | 1388 socket->callbackList.acceptCallback = pkix_pl_Socket_Accept; |
1490 socket->callbackList.connectcontinueCallback = | 1389 socket->callbackList.connectcontinueCallback = pkix_pl_Socket_ConnectContinue; |
1491 pkix_pl_Socket_ConnectContinue; | 1390 socket->callbackList.sendCallback = pkix_pl_Socket_Send; |
1492 socket->callbackList.sendCallback = pkix_pl_Socket_Send; | 1391 socket->callbackList.recvCallback = pkix_pl_Socket_Recv; |
1493 socket->callbackList.recvCallback = pkix_pl_Socket_Recv; | 1392 socket->callbackList.pollCallback = pkix_pl_Socket_Poll; |
1494 socket->callbackList.pollCallback = pkix_pl_Socket_Poll; | 1393 socket->callbackList.shutdownCallback = pkix_pl_Socket_Shutdown; |
1495 socket->callbackList.shutdownCallback = pkix_pl_Socket_Shutdown; | |
1496 | 1394 |
1497 if (isServer) { | 1395 if (isServer) { |
1498 PKIX_CHECK(pkix_pl_Socket_CreateServer(socket, plContext), | 1396 PKIX_CHECK(pkix_pl_Socket_CreateServer(socket, plContext), |
1499 PKIX_SOCKETCREATESERVERFAILED); | 1397 PKIX_SOCKETCREATESERVERFAILED); |
1500 *pStatus = 0; | 1398 *pStatus = 0; |
1501 } else { | 1399 } else { |
1502 PKIX_CHECK(pkix_pl_Socket_CreateClient(socket, plContext), | 1400 PKIX_CHECK(pkix_pl_Socket_CreateClient(socket, plContext), |
1503 PKIX_SOCKETCREATECLIENTFAILED); | 1401 PKIX_SOCKETCREATECLIENTFAILED); |
1504 PKIX_CHECK(pkix_pl_Socket_Connect(socket, pStatus, plContext), | 1402 PKIX_CHECK(pkix_pl_Socket_Connect(socket, pStatus, plContext), |
1505 PKIX_SOCKETCONNECTFAILED); | 1403 PKIX_SOCKETCONNECTFAILED); |
1506 } | 1404 } |
1507 | 1405 |
1508 *pSocket = socket; | 1406 *pSocket = socket; |
1509 | 1407 |
1510 cleanup: | 1408 cleanup: |
1511 PL_strfree(localCopyName); | 1409 PL_strfree(localCopyName); |
1512 | 1410 |
1513 if (PKIX_ERROR_RECEIVED) { | 1411 if (PKIX_ERROR_RECEIVED) { |
1514 PKIX_DECREF(socket); | 1412 PKIX_DECREF(socket); |
1515 } | 1413 } |
1516 | 1414 |
1517 PKIX_RETURN(SOCKET); | 1415 PKIX_RETURN(SOCKET); |
1518 } | 1416 } |
1519 | 1417 |
1520 /* | 1418 /* |
1521 * FUNCTION: pkix_pl_Socket_CreateByHostAndPort | 1419 * FUNCTION: pkix_pl_Socket_CreateByHostAndPort |
1522 * DESCRIPTION: | 1420 * DESCRIPTION: |
1523 * | 1421 * |
1524 * This function creates a new Socket, setting it to be a server or a client | 1422 * This function creates a new Socket, setting it to be a server or a client |
1525 * according to the value of "isServer", setting its timeout value from | 1423 * according to the value of "isServer", setting its timeout value from |
1526 * "timeout", host from "hostname", and port number from "portNum", and stores | 1424 * "timeout", host from "hostname", and port number from "portNum", and stores |
1527 * the status at "pStatus" and the created Socket at "pSocket". | 1425 * the status at "pStatus" and the created Socket at "pSocket". |
(...skipping 21 matching lines...) Expand all Loading... |
1549 * "plContext" | 1447 * "plContext" |
1550 * Platform-specific context pointer. | 1448 * Platform-specific context pointer. |
1551 * THREAD SAFETY: | 1449 * THREAD SAFETY: |
1552 * Thread Safe (see Thread Safety Definitions in Programmer's Guide) | 1450 * Thread Safe (see Thread Safety Definitions in Programmer's Guide) |
1553 * RETURNS: | 1451 * RETURNS: |
1554 * Returns NULL if the function succeeds. | 1452 * Returns NULL if the function succeeds. |
1555 * Returns a Socket Error if the function fails in | 1453 * Returns a Socket Error if the function fails in |
1556 * a non-fatal way. | 1454 * a non-fatal way. |
1557 * Returns a Fatal Error if the function fails in an unrecoverable way. | 1455 * Returns a Fatal Error if the function fails in an unrecoverable way. |
1558 */ | 1456 */ |
1559 PKIX_Error * | 1457 PKIX_Error *pkix_pl_Socket_CreateByHostAndPort(PKIX_Boolean isServer, |
1560 pkix_pl_Socket_CreateByHostAndPort( | 1458 PRIntervalTime timeout, |
1561 PKIX_Boolean isServer, | 1459 char *hostname, PRUint16 portnum, |
1562 PRIntervalTime timeout, | 1460 PRErrorCode *pStatus, |
1563 char *hostname, | 1461 PKIX_PL_Socket **pSocket, |
1564 PRUint16 portnum, | 1462 void *plContext) { |
1565 PRErrorCode *pStatus, | 1463 PRNetAddr netAddr; |
1566 PKIX_PL_Socket **pSocket, | 1464 PKIX_PL_Socket *socket = NULL; |
1567 void *plContext) | 1465 char *sepPtr = NULL; |
1568 { | 1466 PRHostEnt hostent; |
1569 PRNetAddr netAddr; | 1467 PRIntn hostenum; |
1570 PKIX_PL_Socket *socket = NULL; | 1468 PRStatus prstatus = PR_FAILURE; |
1571 char *sepPtr = NULL; | 1469 char buf[PR_NETDB_BUF_SIZE]; |
1572 PRHostEnt hostent; | |
1573 PRIntn hostenum; | |
1574 PRStatus prstatus = PR_FAILURE; | |
1575 char buf[PR_NETDB_BUF_SIZE]; | |
1576 | 1470 |
1577 PKIX_ENTER(SOCKET, "pkix_pl_Socket_CreateByHostAndPort"); | 1471 PKIX_ENTER(SOCKET, "pkix_pl_Socket_CreateByHostAndPort"); |
1578 PKIX_NULLCHECK_THREE(hostname, pStatus, pSocket); | 1472 PKIX_NULLCHECK_THREE(hostname, pStatus, pSocket); |
1579 | 1473 |
| 1474 prstatus = PR_GetHostByName(hostname, buf, sizeof(buf), &hostent); |
1580 | 1475 |
1581 prstatus = PR_GetHostByName(hostname, buf, sizeof(buf), &hostent); | 1476 if ((prstatus != PR_SUCCESS) || (hostent.h_length != 4)) { |
| 1477 /* |
| 1478 * The hostname may be a fully-qualified name. Try using just |
| 1479 * the leftmost component in our lookup. |
| 1480 */ |
| 1481 sepPtr = strchr(hostname, '.'); |
| 1482 if (sepPtr) { |
| 1483 *sepPtr++ = '\0'; |
| 1484 } |
| 1485 prstatus = PR_GetHostByName(hostname, buf, sizeof(buf), &hostent); |
1582 | 1486 |
1583 if ((prstatus != PR_SUCCESS) || (hostent.h_length != 4)) { | 1487 if ((prstatus != PR_SUCCESS) || (hostent.h_length != 4)) { |
1584 /* | 1488 PKIX_ERROR(PKIX_PRGETHOSTBYNAMEREJECTSHOSTNAMEARGUMENT); |
1585 * The hostname may be a fully-qualified name. Try using just | 1489 } |
1586 * the leftmost component in our lookup. | 1490 } |
1587 */ | |
1588 sepPtr = strchr(hostname, '.'); | |
1589 if (sepPtr) { | |
1590 *sepPtr++ = '\0'; | |
1591 } | |
1592 prstatus = PR_GetHostByName(hostname, buf, sizeof(buf), &hostent
); | |
1593 | 1491 |
1594 if ((prstatus != PR_SUCCESS) || (hostent.h_length != 4)) { | 1492 netAddr.inet.family = PR_AF_INET; |
1595 PKIX_ERROR | 1493 netAddr.inet.port = PR_htons(portnum); |
1596 (PKIX_PRGETHOSTBYNAMEREJECTSHOSTNAMEARGUMENT); | |
1597 } | |
1598 } | |
1599 | 1494 |
1600 netAddr.inet.family = PR_AF_INET; | 1495 if (isServer) { |
1601 netAddr.inet.port = PR_htons(portnum); | |
1602 | 1496 |
1603 if (isServer) { | 1497 netAddr.inet.ip = PR_INADDR_ANY; |
1604 | 1498 |
1605 netAddr.inet.ip = PR_INADDR_ANY; | 1499 } else { |
1606 | 1500 |
1607 } else { | 1501 hostenum = PR_EnumerateHostEnt(0, &hostent, portnum, &netAddr); |
| 1502 if (hostenum == -1) { |
| 1503 PKIX_ERROR(PKIX_PRENUMERATEHOSTENTFAILED); |
| 1504 } |
| 1505 } |
1608 | 1506 |
1609 hostenum = PR_EnumerateHostEnt(0, &hostent, portnum, &netAddr); | 1507 PKIX_CHECK(PKIX_PL_Object_Alloc(PKIX_SOCKET_TYPE, sizeof(PKIX_PL_Socket), |
1610 if (hostenum == -1) { | 1508 (PKIX_PL_Object **)&socket, plContext), |
1611 PKIX_ERROR(PKIX_PRENUMERATEHOSTENTFAILED); | 1509 PKIX_COULDNOTCREATESOCKETOBJECT); |
1612 } | |
1613 } | |
1614 | 1510 |
1615 PKIX_CHECK(PKIX_PL_Object_Alloc | 1511 socket->isServer = isServer; |
1616 (PKIX_SOCKET_TYPE, | 1512 socket->timeout = timeout; |
1617 sizeof (PKIX_PL_Socket), | 1513 socket->clientSock = NULL; |
1618 (PKIX_PL_Object **)&socket, | 1514 socket->serverSock = NULL; |
1619 plContext), | 1515 socket->netAddr = &netAddr; |
1620 PKIX_COULDNOTCREATESOCKETOBJECT); | |
1621 | 1516 |
1622 socket->isServer = isServer; | 1517 socket->callbackList.listenCallback = pkix_pl_Socket_Listen; |
1623 socket->timeout = timeout; | 1518 socket->callbackList.acceptCallback = pkix_pl_Socket_Accept; |
1624 socket->clientSock = NULL; | 1519 socket->callbackList.connectcontinueCallback = pkix_pl_Socket_ConnectContinue; |
1625 socket->serverSock = NULL; | 1520 socket->callbackList.sendCallback = pkix_pl_Socket_Send; |
1626 socket->netAddr = &netAddr; | 1521 socket->callbackList.recvCallback = pkix_pl_Socket_Recv; |
| 1522 socket->callbackList.pollCallback = pkix_pl_Socket_Poll; |
| 1523 socket->callbackList.shutdownCallback = pkix_pl_Socket_Shutdown; |
1627 | 1524 |
1628 socket->callbackList.listenCallback = pkix_pl_Socket_Listen; | 1525 if (isServer) { |
1629 socket->callbackList.acceptCallback = pkix_pl_Socket_Accept; | 1526 PKIX_CHECK(pkix_pl_Socket_CreateServer(socket, plContext), |
1630 socket->callbackList.connectcontinueCallback = | 1527 PKIX_SOCKETCREATESERVERFAILED); |
1631 pkix_pl_Socket_ConnectContinue; | 1528 *pStatus = 0; |
1632 socket->callbackList.sendCallback = pkix_pl_Socket_Send; | 1529 } else { |
1633 socket->callbackList.recvCallback = pkix_pl_Socket_Recv; | 1530 PKIX_CHECK(pkix_pl_Socket_CreateClient(socket, plContext), |
1634 socket->callbackList.pollCallback = pkix_pl_Socket_Poll; | 1531 PKIX_SOCKETCREATECLIENTFAILED); |
1635 socket->callbackList.shutdownCallback = pkix_pl_Socket_Shutdown; | 1532 PKIX_CHECK(pkix_pl_Socket_Connect(socket, pStatus, plContext), |
| 1533 PKIX_SOCKETCONNECTFAILED); |
| 1534 } |
1636 | 1535 |
1637 if (isServer) { | 1536 *pSocket = socket; |
1638 PKIX_CHECK(pkix_pl_Socket_CreateServer(socket, plContext), | |
1639 PKIX_SOCKETCREATESERVERFAILED); | |
1640 *pStatus = 0; | |
1641 } else { | |
1642 PKIX_CHECK(pkix_pl_Socket_CreateClient(socket, plContext), | |
1643 PKIX_SOCKETCREATECLIENTFAILED); | |
1644 PKIX_CHECK(pkix_pl_Socket_Connect(socket, pStatus, plContext), | |
1645 PKIX_SOCKETCONNECTFAILED); | |
1646 } | |
1647 | |
1648 *pSocket = socket; | |
1649 | 1537 |
1650 cleanup: | 1538 cleanup: |
1651 if (PKIX_ERROR_RECEIVED) { | 1539 if (PKIX_ERROR_RECEIVED) { |
1652 PKIX_DECREF(socket); | 1540 PKIX_DECREF(socket); |
1653 } | 1541 } |
1654 | 1542 |
1655 PKIX_RETURN(SOCKET); | 1543 PKIX_RETURN(SOCKET); |
1656 } | 1544 } |
1657 | 1545 |
1658 /* | 1546 /* |
1659 * FUNCTION: pkix_pl_Socket_GetCallbackList | 1547 * FUNCTION: pkix_pl_Socket_GetCallbackList |
1660 */ | 1548 */ |
1661 PKIX_Error * | 1549 PKIX_Error *pkix_pl_Socket_GetCallbackList( |
1662 pkix_pl_Socket_GetCallbackList( | 1550 PKIX_PL_Socket *socket, PKIX_PL_Socket_Callback **pCallbackList, |
1663 PKIX_PL_Socket *socket, | 1551 void *plContext) { |
1664 PKIX_PL_Socket_Callback **pCallbackList, | 1552 PKIX_ENTER(SOCKET, "pkix_pl_Socket_GetCallbackList"); |
1665 void *plContext) | 1553 PKIX_NULLCHECK_TWO(socket, pCallbackList); |
1666 { | |
1667 PKIX_ENTER(SOCKET, "pkix_pl_Socket_GetCallbackList"); | |
1668 PKIX_NULLCHECK_TWO(socket, pCallbackList); | |
1669 | 1554 |
1670 *pCallbackList = &(socket->callbackList); | 1555 *pCallbackList = &(socket->callbackList); |
1671 | 1556 |
1672 PKIX_RETURN(SOCKET); | 1557 PKIX_RETURN(SOCKET); |
1673 } | 1558 } |
1674 | 1559 |
1675 /* | 1560 /* |
1676 * FUNCTION: pkix_pl_Socket_GetPRFileDesc | 1561 * FUNCTION: pkix_pl_Socket_GetPRFileDesc |
1677 */ | 1562 */ |
1678 PKIX_Error * | 1563 PKIX_Error *pkix_pl_Socket_GetPRFileDesc(PKIX_PL_Socket *socket, |
1679 pkix_pl_Socket_GetPRFileDesc( | 1564 PRFileDesc **pDesc, void *plContext) { |
1680 PKIX_PL_Socket *socket, | 1565 PKIX_ENTER(SOCKET, "pkix_pl_Socket_GetPRFileDesc"); |
1681 PRFileDesc **pDesc, | 1566 PKIX_NULLCHECK_TWO(socket, pDesc); |
1682 void *plContext) | |
1683 { | |
1684 PKIX_ENTER(SOCKET, "pkix_pl_Socket_GetPRFileDesc"); | |
1685 PKIX_NULLCHECK_TWO(socket, pDesc); | |
1686 | 1567 |
1687 *pDesc = socket->clientSock; | 1568 *pDesc = socket->clientSock; |
1688 | 1569 |
1689 PKIX_RETURN(SOCKET); | 1570 PKIX_RETURN(SOCKET); |
1690 } | 1571 } |
OLD | NEW |