Annotation of embedaddon/curl/docs/examples/http2-pushinmemory.c, revision 1.1
1.1 ! misho 1: /***************************************************************************
! 2: * _ _ ____ _
! 3: * Project ___| | | | _ \| |
! 4: * / __| | | | |_) | |
! 5: * | (__| |_| | _ <| |___
! 6: * \___|\___/|_| \_\_____|
! 7: *
! 8: * Copyright (C) 1998 - 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: /* <DESC>
! 23: * HTTP/2 server push. Receive all data in memory.
! 24: * </DESC>
! 25: */
! 26: #include <stdio.h>
! 27: #include <stdlib.h>
! 28: #include <string.h>
! 29:
! 30: /* somewhat unix-specific */
! 31: #include <sys/time.h>
! 32: #include <unistd.h>
! 33:
! 34: /* curl stuff */
! 35: #include <curl/curl.h>
! 36:
! 37: struct Memory {
! 38: char *memory;
! 39: size_t size;
! 40: };
! 41:
! 42: static size_t
! 43: write_cb(void *contents, size_t size, size_t nmemb, void *userp)
! 44: {
! 45: size_t realsize = size * nmemb;
! 46: struct Memory *mem = (struct Memory *)userp;
! 47: char *ptr = realloc(mem->memory, mem->size + realsize + 1);
! 48: if(!ptr) {
! 49: /* out of memory! */
! 50: printf("not enough memory (realloc returned NULL)\n");
! 51: return 0;
! 52: }
! 53:
! 54: mem->memory = ptr;
! 55: memcpy(&(mem->memory[mem->size]), contents, realsize);
! 56: mem->size += realsize;
! 57: mem->memory[mem->size] = 0;
! 58:
! 59: return realsize;
! 60: }
! 61:
! 62: #define MAX_FILES 10
! 63: static struct Memory files[MAX_FILES];
! 64: static int pushindex = 1;
! 65:
! 66: static void init_memory(struct Memory *chunk)
! 67: {
! 68: chunk->memory = malloc(1); /* grown as needed with realloc */
! 69: chunk->size = 0; /* no data at this point */
! 70: }
! 71:
! 72: static void setup(CURL *hnd)
! 73: {
! 74: /* set the same URL */
! 75: curl_easy_setopt(hnd, CURLOPT_URL, "https://localhost:8443/index.html");
! 76:
! 77: /* HTTP/2 please */
! 78: curl_easy_setopt(hnd, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0);
! 79:
! 80: /* we use a self-signed test server, skip verification during debugging */
! 81: curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYPEER, 0L);
! 82: curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYHOST, 0L);
! 83:
! 84: /* write data to a struct */
! 85: curl_easy_setopt(hnd, CURLOPT_WRITEFUNCTION, write_cb);
! 86: init_memory(&files[0]);
! 87: curl_easy_setopt(hnd, CURLOPT_WRITEDATA, &files[0]);
! 88:
! 89: /* wait for pipe connection to confirm */
! 90: curl_easy_setopt(hnd, CURLOPT_PIPEWAIT, 1L);
! 91: }
! 92:
! 93: /* called when there's an incoming push */
! 94: static int server_push_callback(CURL *parent,
! 95: CURL *easy,
! 96: size_t num_headers,
! 97: struct curl_pushheaders *headers,
! 98: void *userp)
! 99: {
! 100: char *headp;
! 101: int *transfers = (int *)userp;
! 102: (void)parent; /* we have no use for this */
! 103: (void)num_headers; /* unused */
! 104:
! 105: if(pushindex == MAX_FILES)
! 106: /* can't fit anymore */
! 107: return CURL_PUSH_DENY;
! 108:
! 109: /* write to this buffer */
! 110: init_memory(&files[pushindex]);
! 111: curl_easy_setopt(easy, CURLOPT_WRITEDATA, &files[pushindex]);
! 112: pushindex++;
! 113:
! 114: headp = curl_pushheader_byname(headers, ":path");
! 115: if(headp)
! 116: fprintf(stderr, "* Pushed :path '%s'\n", headp /* skip :path + colon */);
! 117:
! 118: (*transfers)++; /* one more */
! 119: return CURL_PUSH_OK;
! 120: }
! 121:
! 122:
! 123: /*
! 124: * Download a file over HTTP/2, take care of server push.
! 125: */
! 126: int main(void)
! 127: {
! 128: CURL *easy;
! 129: CURLM *multi;
! 130: int still_running; /* keep number of running handles */
! 131: int transfers = 1; /* we start with one */
! 132: int i;
! 133: struct CURLMsg *m;
! 134:
! 135: /* init a multi stack */
! 136: multi = curl_multi_init();
! 137:
! 138: easy = curl_easy_init();
! 139:
! 140: /* set options */
! 141: setup(easy);
! 142:
! 143: /* add the easy transfer */
! 144: curl_multi_add_handle(multi, easy);
! 145:
! 146: curl_multi_setopt(multi, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
! 147: curl_multi_setopt(multi, CURLMOPT_PUSHFUNCTION, server_push_callback);
! 148: curl_multi_setopt(multi, CURLMOPT_PUSHDATA, &transfers);
! 149:
! 150: while(transfers) {
! 151: int rc;
! 152: CURLMcode mcode = curl_multi_perform(multi, &still_running);
! 153: if(mcode)
! 154: break;
! 155:
! 156: mcode = curl_multi_wait(multi, NULL, 0, 1000, &rc);
! 157: if(mcode)
! 158: break;
! 159:
! 160:
! 161: /*
! 162: * When doing server push, libcurl itself created and added one or more
! 163: * easy handles but *we* need to clean them up when they are done.
! 164: */
! 165: do {
! 166: int msgq = 0;;
! 167: m = curl_multi_info_read(multi, &msgq);
! 168: if(m && (m->msg == CURLMSG_DONE)) {
! 169: CURL *e = m->easy_handle;
! 170: transfers--;
! 171: curl_multi_remove_handle(multi, e);
! 172: curl_easy_cleanup(e);
! 173: }
! 174: } while(m);
! 175:
! 176: }
! 177:
! 178:
! 179: curl_multi_cleanup(multi);
! 180:
! 181: /* 'pushindex' is now the number of received transfers */
! 182: for(i = 0; i < pushindex; i++) {
! 183: /* do something fun with the data, and then free it when done */
! 184: free(files[i].memory);
! 185: }
! 186:
! 187: return 0;
! 188: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to http2-pushinmemory.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 / docs / examples