libs3-1.4/src/request_context.c

   1 /** **************************************************************************
   2  * request_context.c
   3  *
   4  * Copyright 2008 Bryan Ischo <bryan@ischo.com>
   5  *
   6  * This file is part of libs3.
   7  *
   8  * libs3 is free software: you can redistribute it and/or modify it under the
   9  * terms of the GNU General Public License as published by the Free Software
  10  * Foundation, version 3 of the License.
  11  *
  12  * In addition, as a special exception, the copyright holders give
  13  * permission to link the code of this library and its programs with the
  14  * OpenSSL library, and distribute linked combinations including the two.
  15  *
  16  * libs3 is distributed in the hope that it will be useful, but WITHOUT ANY
  17  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  18  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  19  * details.
  20  *
  21  * You should have received a copy of the GNU General Public License version 3
  22  * along with libs3, in a file named COPYING.  If not, see
  23  * <http://www.gnu.org/licenses/>.
  24  *
  25  ************************************************************************** **/
  26
  27 #include <curl/curl.h>
  28 #include <stdlib.h>
  29 #include <sys/select.h>
  30 #include "request.h"
  31 #include "request_context.h"
  32
  33
  34 S3Status S3_create_request_context(S3RequestContext **requestContextReturn)
  35 {
  36     *requestContextReturn =
  37         (S3RequestContext *) malloc(sizeof(S3RequestContext));
  38
  39     if (!*requestContextReturn) {
  40         return S3StatusOutOfMemory;
  41     }
  42
  43     if (!((*requestContextReturn)->curlm = curl_multi_init())) {
  44         free(*requestContextReturn);
  45         return S3StatusOutOfMemory;
  46     }
  47
  48     (*requestContextReturn)->requests = 0;
  49
  50     return S3StatusOK;
  51 }
  52
  53
  54 void S3_destroy_request_context(S3RequestContext *requestContext)
  55 {
  56     curl_multi_cleanup(requestContext->curlm);
  57
  58     // For each request in the context, call back its done method with
  59     // 'interrupted' status
  60     Request *r = requestContext->requests, *rFirst = r;
  61
  62     if (r) do {
  63         r->status = S3StatusInterrupted;
  64         Request *rNext = r->next;
  65         request_finish(r);
  66         r = rNext;
  67     } while (r != rFirst);
  68
  69     free(requestContext);
  70 }
  71
  72
  73 S3Status S3_runall_request_context(S3RequestContext *requestContext)
  74 {
  75     int requestsRemaining;
  76     do {
  77         fd_set readfds, writefds, exceptfds;
  78         FD_ZERO(&readfds);
  79         FD_ZERO(&writefds);
  80         FD_ZERO(&exceptfds);
  81         int maxfd;
  82         S3Status status = S3_get_request_context_fdsets
  83             (requestContext, &readfds, &writefds, &exceptfds, &maxfd);
  84         if (status != S3StatusOK) {
  85             return status;
  86         }
  87         // curl will return -1 if it hasn't even created any fds yet because
  88         // none of the connections have started yet.  In this case, don't
  89         // do the select at all, because it will wait forever; instead, just
  90         // skip it and go straight to running the underlying CURL handles
  91         if (maxfd != -1) {
  92             int64_t timeout = S3_get_request_context_timeout(requestContext);
  93             struct timeval tv = { timeout / 1000, (timeout % 1000) * 1000 };
  94             select(maxfd + 1, &readfds, &writefds, &exceptfds,
  95                    (timeout == -1) ? 0 : &tv);
  96         }
  97         status = S3_runonce_request_context(requestContext,
  98                                             &requestsRemaining);
  99         if (status != S3StatusOK) {
 100             return status;
 101         }
 102     } while (requestsRemaining);
 103
 104     return S3StatusOK;
 105 }
 106
 107
 108 S3Status S3_runonce_request_context(S3RequestContext *requestContext,
 109                                     int *requestsRemainingReturn)
 110 {
 111     CURLMcode status;
 112
 113     do {
 114         status = curl_multi_perform(requestContext->curlm,
 115                                     requestsRemainingReturn);
 116
 117         switch (status) {
 118         case CURLM_OK:
 119         case CURLM_CALL_MULTI_PERFORM:
 120             break;
 121         case CURLM_OUT_OF_MEMORY:
 122             return S3StatusOutOfMemory;
 123         default:
 124             return S3StatusInternalError;
 125         }
 126
 127         CURLMsg *msg;
 128         int junk;
 129         while ((msg = curl_multi_info_read(requestContext->curlm, &junk))) {
 130             if (msg->msg != CURLMSG_DONE) {
 131                 return S3StatusInternalError;
 132             }
 133             Request *request;
 134             if (curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE,
 135                                   (char **) (char *) &request) != CURLE_OK) {
 136                 return S3StatusInternalError;
 137             }
 138             // Remove the request from the list of requests
 139             if (request->prev == request->next) {
 140                 // It was the only one on the list
 141                 requestContext->requests = 0;
 142             }
 143             else {
 144                 // It doesn't matter what the order of them are, so just in
 145                 // case request was at the head of the list, put the one after
 146                 // request to the head of the list
 147                 requestContext->requests = request->next;
 148                 request->prev->next = request->next;
 149                 request->next->prev = request->prev;
 150             }
 151             if ((msg->data.result != CURLE_OK) &&
 152                 (request->status == S3StatusOK)) {
 153                 request->status = request_curl_code_to_status
 154                     (msg->data.result);
 155             }
 156             if (curl_multi_remove_handle(requestContext->curlm,
 157                                          msg->easy_handle) != CURLM_OK) {
 158                 return S3StatusInternalError;
 159             }
 160             // Finish the request, ensuring that all callbacks have been made,
 161             // and also releases the request
 162             request_finish(request);
 163             // Now, since a callback was made, there may be new requests
 164             // queued up to be performed immediately, so do so
 165             status = CURLM_CALL_MULTI_PERFORM;
 166         }
 167     } while (status == CURLM_CALL_MULTI_PERFORM);
 168
 169     return S3StatusOK;
 170 }
 171
 172 S3Status S3_get_request_context_fdsets(S3RequestContext *requestContext,
 173                                        fd_set *readFdSet, fd_set *writeFdSet,
 174                                        fd_set *exceptFdSet, int *maxFd)
 175 {
 176     return ((curl_multi_fdset(requestContext->curlm, readFdSet, writeFdSet,
 177                               exceptFdSet, maxFd) == CURLM_OK) ?
 178             S3StatusOK : S3StatusInternalError);
 179 }
 180
 181 int64_t S3_get_request_context_timeout(S3RequestContext *requestContext)
 182 {
 183     long timeout;
 184
 185     if (curl_multi_timeout(requestContext->curlm, &timeout) != CURLM_OK) {
 186         timeout = 0;
 187     }
 188
 189     return timeout;
 190 }