1: /***************************************************************************
2: * _ _ ____ _
3: * Project ___| | | | _ \| |
4: * / __| | | | |_) | |
5: * | (__| |_| | _ <| |___
6: * \___|\___/|_| \_\_____|
7: *
8: * Copyright (C) 2012 - 2018, Daniel Stenberg, <daniel@haxx.se>, et al.
9: *
10: * This software is licensed as described in the file COPYING, which
11: * you should have received as part of this distribution. The terms
12: * are also available at https://curl.haxx.se/docs/copyright.html.
13: *
14: * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15: * copies of the Software, and permit persons to whom the Software is
16: * furnished to do so, under the terms of the COPYING file.
17: *
18: * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19: * KIND, either express or implied.
20: *
21: ***************************************************************************/
22: #include "test.h"
23:
24: #include <limits.h>
25: #include <assert.h>
26:
27: #include "testutil.h"
28: #include "warnless.h"
29: #include "memdebug.h"
30:
31: #define TEST_HANG_TIMEOUT 5 * 1000
32: #define MAX_EASY_HANDLES 3
33:
34: static int counter[MAX_EASY_HANDLES];
35: static CURL *easy[MAX_EASY_HANDLES];
36: static curl_socket_t sockets[MAX_EASY_HANDLES];
37: static int res = 0;
38:
39: static size_t callback(char *ptr, size_t size, size_t nmemb, void *data)
40: {
41: ssize_t idx = ((CURL **) data) - easy;
42: curl_socket_t sock;
43: long longdata;
44: CURLcode code;
45: const size_t failure = (size && nmemb) ? 0 : 1;
46: (void)ptr;
47:
48: counter[idx] += (int)(size * nmemb);
49:
50: /* Get socket being used for this easy handle, otherwise CURL_SOCKET_BAD */
51: code = curl_easy_getinfo(easy[idx], CURLINFO_LASTSOCKET, &longdata);
52: if(CURLE_OK != code) {
53: fprintf(stderr, "%s:%d curl_easy_getinfo() failed, "
54: "with code %d (%s)\n",
55: __FILE__, __LINE__, (int)code, curl_easy_strerror(code));
56: res = TEST_ERR_MAJOR_BAD;
57: return failure;
58: }
59: if(longdata == -1L)
60: sock = CURL_SOCKET_BAD;
61: else
62: sock = (curl_socket_t)longdata;
63:
64: if(sock != CURL_SOCKET_BAD) {
65: /* Track relationship between this easy handle and the socket. */
66: if(sockets[idx] == CURL_SOCKET_BAD) {
67: /* An easy handle without previous socket, record the socket. */
68: sockets[idx] = sock;
69: }
70: else if(sock != sockets[idx]) {
71: /* An easy handle with a socket different to previously
72: tracked one, log and fail right away. Known bug #37. */
73: fprintf(stderr, "Handle %d started on socket %d and moved to %d\n",
74: curlx_sztosi(idx), (int)sockets[idx], (int)sock);
75: res = TEST_ERR_MAJOR_BAD;
76: return failure;
77: }
78: }
79: return size * nmemb;
80: }
81:
82: enum HandleState {
83: ReadyForNewHandle,
84: NeedSocketForNewHandle,
85: NoMoreHandles
86: };
87:
88: int test(char *url)
89: {
90: CURLM *multi = NULL;
91: int running;
92: int i;
93: int num_handles = 0;
94: enum HandleState state = ReadyForNewHandle;
95: size_t urllen = strlen(url) + 4 + 1;
96: char *full_url = malloc(urllen);
97:
98: start_test_timing();
99:
100: if(!full_url) {
101: fprintf(stderr, "Not enough memory for full url\n");
102: return TEST_ERR_MAJOR_BAD;
103: }
104:
105: for(i = 0; i < MAX_EASY_HANDLES; ++i) {
106: easy[i] = NULL;
107: sockets[i] = CURL_SOCKET_BAD;
108: }
109:
110: res_global_init(CURL_GLOBAL_ALL);
111: if(res) {
112: free(full_url);
113: return res;
114: }
115:
116: multi_init(multi);
117:
118: #ifdef USE_PIPELINING
119: multi_setopt(multi, CURLMOPT_PIPELINING, 1L);
120: multi_setopt(multi, CURLMOPT_MAX_HOST_CONNECTIONS, 5L);
121: multi_setopt(multi, CURLMOPT_MAX_TOTAL_CONNECTIONS, 10L);
122: #endif
123:
124: for(;;) {
125: struct timeval interval;
126: fd_set fdread;
127: fd_set fdwrite;
128: fd_set fdexcep;
129: long timeout = -99;
130: int maxfd = -99;
131: bool found_new_socket = FALSE;
132:
133: /* Start a new handle if we aren't at the max */
134: if(state == ReadyForNewHandle) {
135: easy_init(easy[num_handles]);
136:
137: if(num_handles % 3 == 2) {
138: msnprintf(full_url, urllen, "%s0200", url);
139: easy_setopt(easy[num_handles], CURLOPT_HTTPAUTH, CURLAUTH_NTLM);
140: }
141: else {
142: msnprintf(full_url, urllen, "%s0100", url);
143: easy_setopt(easy[num_handles], CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
144: }
145: easy_setopt(easy[num_handles], CURLOPT_FRESH_CONNECT, 1L);
146: easy_setopt(easy[num_handles], CURLOPT_URL, full_url);
147: easy_setopt(easy[num_handles], CURLOPT_VERBOSE, 1L);
148: easy_setopt(easy[num_handles], CURLOPT_HTTPGET, 1L);
149: easy_setopt(easy[num_handles], CURLOPT_USERPWD, "testuser:testpass");
150: easy_setopt(easy[num_handles], CURLOPT_WRITEFUNCTION, callback);
151: easy_setopt(easy[num_handles], CURLOPT_WRITEDATA, easy + num_handles);
152: easy_setopt(easy[num_handles], CURLOPT_HEADER, 1L);
153:
154: multi_add_handle(multi, easy[num_handles]);
155: num_handles += 1;
156: state = NeedSocketForNewHandle;
157: }
158:
159: multi_perform(multi, &running);
160:
161: fprintf(stderr, "%s:%d running %d state %d\n",
162: __FILE__, __LINE__, running, state);
163:
164: abort_on_test_timeout();
165:
166: if(!running && state == NoMoreHandles)
167: break; /* done */
168:
169: FD_ZERO(&fdread);
170: FD_ZERO(&fdwrite);
171: FD_ZERO(&fdexcep);
172:
173: multi_fdset(multi, &fdread, &fdwrite, &fdexcep, &maxfd);
174:
175: /* At this point, maxfd is guaranteed to be greater or equal than -1. */
176:
177: if(state == NeedSocketForNewHandle) {
178: if(maxfd != -1 && !found_new_socket) {
179: fprintf(stderr, "Warning: socket did not open immediately for new "
180: "handle (trying again)\n");
181: continue;
182: }
183: state = num_handles < MAX_EASY_HANDLES ? ReadyForNewHandle
184: : NoMoreHandles;
185: fprintf(stderr, "%s:%d new state %d\n",
186: __FILE__, __LINE__, state);
187: }
188:
189: multi_timeout(multi, &timeout);
190:
191: /* At this point, timeout is guaranteed to be greater or equal than -1. */
192:
193: fprintf(stderr, "%s:%d num_handles %d timeout %ld running %d\n",
194: __FILE__, __LINE__, num_handles, timeout, running);
195:
196: if(timeout != -1L) {
197: int itimeout = (timeout > (long)INT_MAX) ? INT_MAX : (int)timeout;
198: interval.tv_sec = itimeout/1000;
199: interval.tv_usec = (itimeout%1000)*1000;
200: }
201: else {
202: interval.tv_sec = 0;
203: interval.tv_usec = 5000;
204:
205: /* if there's no timeout and we get here on the last handle, we may
206: already have read the last part of the stream so waiting makes no
207: sense */
208: if(!running && num_handles == MAX_EASY_HANDLES) {
209: break;
210: }
211: }
212:
213: select_test(maxfd + 1, &fdread, &fdwrite, &fdexcep, &interval);
214:
215: abort_on_test_timeout();
216: }
217:
218: test_cleanup:
219:
220: /* proper cleanup sequence - type PB */
221:
222: for(i = 0; i < MAX_EASY_HANDLES; i++) {
223: printf("Data connection %d: %d\n", i, counter[i]);
224: curl_multi_remove_handle(multi, easy[i]);
225: curl_easy_cleanup(easy[i]);
226: }
227:
228: curl_multi_cleanup(multi);
229: curl_global_cleanup();
230:
231: free(full_url);
232:
233: return res;
234: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to libntlmconnect.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / tests / libtest