Return to sendrecv.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / docs / examples

Annotation of embedaddon/curl/docs/examples/sendrecv.c, revision 1.1.1.1

1.1       misho       1: /***************************************************************************
                      2:  *                                  _   _ ____  _
                      3:  *  Project                     ___| | | |  _ \| |
                      4:  *                             / __| | | | |_) | |
                      5:  *                            | (__| |_| |  _ <| |___
                      6:  *                             \___|\___/|_| \_\_____|
                      7:  *
                      8:  * Copyright (C) 1998 - 2019, 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: /* <DESC>
                     23:  * An example of curl_easy_send() and curl_easy_recv() usage.
                     24:  * </DESC>
                     25:  */
                     26: 
                     27: #include <stdio.h>
                     28: #include <string.h>
                     29: #include <curl/curl.h>
                     30: 
                     31: /* Auxiliary function that waits on the socket. */
                     32: static int wait_on_socket(curl_socket_t sockfd, int for_recv, long timeout_ms)
                     33: {
                     34:   struct timeval tv;
                     35:   fd_set infd, outfd, errfd;
                     36:   int res;
                     37: 
                     38:   tv.tv_sec = timeout_ms / 1000;
                     39:   tv.tv_usec = (timeout_ms % 1000) * 1000;
                     40: 
                     41:   FD_ZERO(&infd);
                     42:   FD_ZERO(&outfd);
                     43:   FD_ZERO(&errfd);
                     44: 
                     45:   FD_SET(sockfd, &errfd); /* always check for error */
                     46: 
                     47:   if(for_recv) {
                     48:     FD_SET(sockfd, &infd);
                     49:   }
                     50:   else {
                     51:     FD_SET(sockfd, &outfd);
                     52:   }
                     53: 
                     54:   /* select() returns the number of signalled sockets or -1 */
                     55:   res = select((int)sockfd + 1, &infd, &outfd, &errfd, &tv);
                     56:   return res;
                     57: }
                     58: 
                     59: int main(void)
                     60: {
                     61:   CURL *curl;
                     62:   /* Minimalistic http request */
                     63:   const char *request = "GET / HTTP/1.0\r\nHost: example.com\r\n\r\n";
                     64:   size_t request_len = strlen(request);
                     65: 
                     66:   /* A general note of caution here: if you're using curl_easy_recv() or
                     67:      curl_easy_send() to implement HTTP or _any_ other protocol libcurl
                     68:      supports "natively", you're doing it wrong and you should stop.
                     69: 
                     70:      This example uses HTTP only to show how to use this API, it does not
                     71:      suggest that writing an application doing this is sensible.
                     72:   */
                     73: 
                     74:   curl = curl_easy_init();
                     75:   if(curl) {
                     76:     CURLcode res;
                     77:     curl_socket_t sockfd;
                     78:     size_t nsent_total = 0;
                     79: 
                     80:     curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
                     81:     /* Do not do the transfer - only connect to host */
                     82:     curl_easy_setopt(curl, CURLOPT_CONNECT_ONLY, 1L);
                     83:     res = curl_easy_perform(curl);
                     84: 
                     85:     if(res != CURLE_OK) {
                     86:       printf("Error: %s\n", curl_easy_strerror(res));
                     87:       return 1;
                     88:     }
                     89: 
                     90:     /* Extract the socket from the curl handle - we'll need it for waiting. */
                     91:     res = curl_easy_getinfo(curl, CURLINFO_ACTIVESOCKET, &sockfd);
                     92: 
                     93:     if(res != CURLE_OK) {
                     94:       printf("Error: %s\n", curl_easy_strerror(res));
                     95:       return 1;
                     96:     }
                     97: 
                     98:     printf("Sending request.\n");
                     99: 
                    100:     do {
                    101:       /* Warning: This example program may loop indefinitely.
                    102:        * A production-quality program must define a timeout and exit this loop
                    103:        * as soon as the timeout has expired. */
                    104:       size_t nsent;
                    105:       do {
                    106:         nsent = 0;
                    107:         res = curl_easy_send(curl, request + nsent_total,
                    108:             request_len - nsent_total, &nsent);
                    109:         nsent_total += nsent;
                    110: 
                    111:         if(res == CURLE_AGAIN && !wait_on_socket(sockfd, 0, 60000L)) {
                    112:           printf("Error: timeout.\n");
                    113:           return 1;
                    114:         }
                    115:       } while(res == CURLE_AGAIN);
                    116: 
                    117:       if(res != CURLE_OK) {
                    118:         printf("Error: %s\n", curl_easy_strerror(res));
                    119:         return 1;
                    120:       }
                    121: 
                    122:       printf("Sent %" CURL_FORMAT_CURL_OFF_T " bytes.\n",
                    123:         (curl_off_t)nsent);
                    124: 
                    125:     } while(nsent_total < request_len);
                    126: 
                    127:     printf("Reading response.\n");
                    128: 
                    129:     for(;;) {
                    130:       /* Warning: This example program may loop indefinitely (see above). */
                    131:       char buf[1024];
                    132:       size_t nread;
                    133:       do {
                    134:         nread = 0;
                    135:         res = curl_easy_recv(curl, buf, sizeof(buf), &nread);
                    136: 
                    137:         if(res == CURLE_AGAIN && !wait_on_socket(sockfd, 1, 60000L)) {
                    138:           printf("Error: timeout.\n");
                    139:           return 1;
                    140:         }
                    141:       } while(res == CURLE_AGAIN);
                    142: 
                    143:       if(res != CURLE_OK) {
                    144:         printf("Error: %s\n", curl_easy_strerror(res));
                    145:         break;
                    146:       }
                    147: 
                    148:       if(nread == 0) {
                    149:         /* end of the response */
                    150:         break;
                    151:       }
                    152: 
                    153:       printf("Received %" CURL_FORMAT_CURL_OFF_T " bytes.\n",
                    154:         (curl_off_t)nread);
                    155:     }
                    156: 
                    157:     /* always cleanup */
                    158:     curl_easy_cleanup(curl);
                    159:   }
                    160:   return 0;
                    161: }