1/***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) 1998 - 2020, 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.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 <fcntl.h>
25
26#include "testutil.h"
27#include "warnless.h"
28#include "memdebug.h"
29
30#define TEST_HANG_TIMEOUT 60 * 1000
31
32struct Sockets
33{
34 curl_socket_t *sockets;
35 int count; /* number of sockets actually stored in array */
36 int max_count; /* max number of sockets that fit in allocated array */
37};
38
39struct ReadWriteSockets
40{
41 struct Sockets read, write;
42};
43
44/**
45 * Remove a file descriptor from a sockets array.
46 */
47static void removeFd(struct Sockets *sockets, curl_socket_t fd, int mention)
48{
49 int i;
50
51 if(mention)
52 fprintf(stderr, "Remove socket fd %d\n", (int) fd);
53
54 for(i = 0; i < sockets->count; ++i) {
55 if(sockets->sockets[i] == fd) {
56 if(i < sockets->count - 1)
57 memmove(&sockets->sockets[i], &sockets->sockets[i + 1],
58 sizeof(curl_socket_t) * (sockets->count - (i + 1)));
59 --sockets->count;
60 }
61 }
62}
63
64/**
65 * Add a file descriptor to a sockets array.
66 */
67static void addFd(struct Sockets *sockets, curl_socket_t fd, const char *what)
68{
69 /**
70 * To ensure we only have each file descriptor once, we remove it then add
71 * it again.
72 */
73 fprintf(stderr, "Add socket fd %d for %s\n", (int) fd, what);
74 removeFd(sockets, fd, 0);
75 /*
76 * Allocate array storage when required.
77 */
78 if(!sockets->sockets) {
79 sockets->sockets = malloc(sizeof(curl_socket_t) * 20U);
80 if(!sockets->sockets)
81 return;
82 sockets->max_count = 20;
83 }
84 else if(sockets->count + 1 > sockets->max_count) {
85 curl_socket_t *oldptr = sockets->sockets;
86 sockets->sockets = realloc(oldptr, sizeof(curl_socket_t) *
87 (sockets->max_count + 20));
88 if(!sockets->sockets) {
89 /* cleanup in test_cleanup */
90 sockets->sockets = oldptr;
91 return;
92 }
93 sockets->max_count += 20;
94 }
95 /*
96 * Add file descriptor to array.
97 */
98 sockets->sockets[sockets->count] = fd;
99 ++sockets->count;
100}
101
102/**
103 * Callback invoked by curl to poll reading / writing of a socket.
104 */
105static int curlSocketCallback(CURL *easy, curl_socket_t s, int action,
106 void *userp, void *socketp)
107{
108 struct ReadWriteSockets *sockets = userp;
109
110 (void)easy; /* unused */
111 (void)socketp; /* unused */
112
113 if(action == CURL_POLL_IN || action == CURL_POLL_INOUT)
114 addFd(&sockets->read, s, "read");
115
116 if(action == CURL_POLL_OUT || action == CURL_POLL_INOUT)
117 addFd(&sockets->write, s, "write");
118
119 if(action == CURL_POLL_REMOVE) {
120 removeFd(&sockets->read, s, 1);
121 removeFd(&sockets->write, s, 0);
122 }
123
124 return 0;
125}
126
127/**
128 * Callback invoked by curl to set a timeout.
129 */
130static int curlTimerCallback(CURLM *multi, long timeout_ms, void *userp)
131{
132 struct timeval *timeout = userp;
133
134 (void)multi; /* unused */
135 if(timeout_ms != -1) {
136 *timeout = tutil_tvnow();
137 timeout->tv_usec += timeout_ms * 1000;
138 }
139 else {
140 timeout->tv_sec = -1;
141 }
142 return 0;
143}
144
145/**
146 * Check for curl completion.
147 */
148static int checkForCompletion(CURLM *curl, int *success)
149{
150 int numMessages;
151 CURLMsg *message;
152 int result = 0;
153 *success = 0;
154 while((message = curl_multi_info_read(curl, &numMessages)) != NULL) {
155 if(message->msg == CURLMSG_DONE) {
156 result = 1;
157 if(message->data.result == CURLE_OK)
158 *success = 1;
159 else
160 *success = 0;
161 }
162 else {
163 fprintf(stderr, "Got an unexpected message from curl: %i\n",
164 (int)message->msg);
165 result = 1;
166 *success = 0;
167 }
168 }
169 return result;
170}
171
172static int getMicroSecondTimeout(struct timeval *timeout)
173{
174 struct timeval now;
175 ssize_t result;
176 now = tutil_tvnow();
177 result = (ssize_t)((timeout->tv_sec - now.tv_sec) * 1000000 +
178 timeout->tv_usec - now.tv_usec);
179 if(result < 0)
180 result = 0;
181
182 return curlx_sztosi(result);
183}
184
185/**
186 * Update a fd_set with all of the sockets in use.
187 */
188static void updateFdSet(struct Sockets *sockets, fd_set* fdset,
189 curl_socket_t *maxFd)
190{
191 int i;
192 for(i = 0; i < sockets->count; ++i) {
193 FD_SET(sockets->sockets[i], fdset);
194 if(*maxFd < sockets->sockets[i] + 1) {
195 *maxFd = sockets->sockets[i] + 1;
196 }
197 }
198}
199
200static void notifyCurl(CURLM *curl, curl_socket_t s, int evBitmask,
201 const char *info)
202{
203 int numhandles = 0;
204 CURLMcode result = curl_multi_socket_action(curl, s, evBitmask, &numhandles);
205 if(result != CURLM_OK) {
206 fprintf(stderr, "Curl error on %s: %i (%s)\n",
207 info, result, curl_multi_strerror(result));
208 }
209}
210
211/**
212 * Invoke curl when a file descriptor is set.
213 */
214static void checkFdSet(CURLM *curl, struct Sockets *sockets, fd_set *fdset,
215 int evBitmask, const char *name)
216{
217 int i;
218 for(i = 0; i < sockets->count; ++i) {
219 if(FD_ISSET(sockets->sockets[i], fdset)) {
220 notifyCurl(curl, sockets->sockets[i], evBitmask, name);
221 }
222 }
223}
224
225int test(char *URL)
226{
227 int res = 0;
228 CURL *curl = NULL;
229 FILE *hd_src = NULL;
230 int hd;
231 struct_stat file_info;
232 CURLM *m = NULL;
233 struct ReadWriteSockets sockets = {{NULL, 0, 0}, {NULL, 0, 0}};
234 struct timeval timeout = {-1, 0};
235 int success = 0;
236
237 start_test_timing();
238
239 if(!libtest_arg3) {
240 fprintf(stderr, "Usage: lib582 [url] [filename] [username]\n");
241 return TEST_ERR_USAGE;
242 }
243
244 hd_src = fopen(libtest_arg2, "rb");
245 if(NULL == hd_src) {
246 fprintf(stderr, "fopen() failed with error: %d (%s)\n",
247 errno, strerror(errno));
248 fprintf(stderr, "Error opening file: (%s)\n", libtest_arg2);
249 return TEST_ERR_FOPEN;
250 }
251
252 /* get the file size of the local file */
253 hd = fstat(fileno(hd_src), &file_info);
254 if(hd == -1) {
255 /* can't open file, bail out */
256 fprintf(stderr, "fstat() failed with error: %d (%s)\n",
257 errno, strerror(errno));
258 fprintf(stderr, "ERROR: cannot open file (%s)\n", libtest_arg2);
259 fclose(hd_src);
260 return TEST_ERR_FSTAT;
261 }
262 fprintf(stderr, "Set to upload %d bytes\n", (int)file_info.st_size);
263
264 res_global_init(CURL_GLOBAL_ALL);
265 if(res) {
266 fclose(hd_src);
267 return res;
268 }
269
270 easy_init(curl);
271
272 /* enable uploading */
273 easy_setopt(curl, CURLOPT_UPLOAD, 1L);
274
275 /* specify target */
276 easy_setopt(curl, CURLOPT_URL, URL);
277
278 /* go verbose */
279 easy_setopt(curl, CURLOPT_VERBOSE, 1L);
280
281 /* now specify which file to upload */
282 easy_setopt(curl, CURLOPT_READDATA, hd_src);
283
284 easy_setopt(curl, CURLOPT_USERPWD, libtest_arg3);
285 easy_setopt(curl, CURLOPT_SSH_PUBLIC_KEYFILE, "curl_client_key.pub");
286 easy_setopt(curl, CURLOPT_SSH_PRIVATE_KEYFILE, "curl_client_key");
287 easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
288
289 easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)file_info.st_size);
290
291 multi_init(m);
292
293 multi_setopt(m, CURLMOPT_SOCKETFUNCTION, curlSocketCallback);
294 multi_setopt(m, CURLMOPT_SOCKETDATA, &sockets);
295
296 multi_setopt(m, CURLMOPT_TIMERFUNCTION, curlTimerCallback);
297 multi_setopt(m, CURLMOPT_TIMERDATA, &timeout);
298
299 multi_add_handle(m, curl);
300
301 while(!checkForCompletion(m, &success)) {
302 fd_set readSet, writeSet;
303 curl_socket_t maxFd = 0;
304 struct timeval tv = {10, 0};
305
306 FD_ZERO(&readSet);
307 FD_ZERO(&writeSet);
308 updateFdSet(&sockets.read, &readSet, &maxFd);
309 updateFdSet(&sockets.write, &writeSet, &maxFd);
310
311 if(timeout.tv_sec != -1) {
312 int usTimeout = getMicroSecondTimeout(&timeout);
313 tv.tv_sec = usTimeout / 1000000;
314 tv.tv_usec = usTimeout % 1000000;
315 }
316 else if(maxFd <= 0) {
317 tv.tv_sec = 0;
318 tv.tv_usec = 100000;
319 }
320
321 select_test((int)maxFd, &readSet, &writeSet, NULL, &tv);
322
323 /* Check the sockets for reading / writing */
324 checkFdSet(m, &sockets.read, &readSet, CURL_CSELECT_IN, "read");
325 checkFdSet(m, &sockets.write, &writeSet, CURL_CSELECT_OUT, "write");
326
327 if(timeout.tv_sec != -1 && getMicroSecondTimeout(&timeout) == 0) {
328 /* Curl's timer has elapsed. */
329 notifyCurl(m, CURL_SOCKET_TIMEOUT, 0, "timeout");
330 }
331
332 abort_on_test_timeout();
333 }
334
335 if(!success) {
336 fprintf(stderr, "Error uploading file.\n");
337 res = TEST_ERR_MAJOR_BAD;
338 }
339
340test_cleanup:
341
342 /* proper cleanup sequence - type PB */
343
344 curl_multi_remove_handle(m, curl);
345 curl_easy_cleanup(curl);
346 curl_multi_cleanup(m);
347 curl_global_cleanup();
348
349 /* close the local file */
350 fclose(hd_src);
351
352 /* free local memory */
353 free(sockets.read.sockets);
354 free(sockets.write.sockets);
355
356 return res;
357}
358