Annotation of embedaddon/curl/docs/examples/http2-pushinmemory.c, revision 1.1.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>