Artifactspublic-v0

curl

master
ply4 git calls30 ms298 KiB3 cachedprotocol v2
1491 lines37 KiBRaw
1/***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) 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 * SPDX-License-Identifier: curl
22 *
23 *
24 ***************************************************************************/
26/* CCSID API wrappers for OS/400. */
28#include <iconv.h>
29#include <string.h>
30#include <stdlib.h>
31#include <stddef.h>
32#include <errno.h>
33#include <stdarg.h>
35#pragma enum(int)
37#include "curl_setup.h"
38#include "curl.h"
39#include "mprintf.h"
40#include "slist.h"
41#include "urldata.h"
42#include "url.h"
43#include "setopt.h"
44#include "getinfo.h"
45#include "curlx/dynbuf.h"
46#include "ccsidcurl.h"
48#include "os400sys.h"
50#ifndef SIZE_MAX
51#define SIZE_MAX ((size_t)~0)
52#endif
54#define ASCII_CCSID 819 /* Use ISO-8859-1 as ASCII. */
55#define NOCONV_CCSID 65535 /* No conversion. */
56#define ICONV_ID_SIZE 32 /* Size of iconv_open() code identifier. */
57#define ICONV_OPEN_ERROR(t) ((t).return_value == -1)
59#define ALLOC_GRANULE 8 /* Alloc. granule for curl_formadd_ccsid(). */
61/* A string terminator that works for all CCSIDs. */
62static const char universal_terminator[] = { 0, 0, 0, 0 };
64/* Freeing const pointers more easily. */
65#define untyped_free(p) curlx_free(CURL_UNCONST(p))
67static void makeOS400IconvCode(char buf[ICONV_ID_SIZE], unsigned int ccsid)
69 /*
70 * Convert a CCSID to the corresponding IBM iconv_open() character
71 * code identifier.
72 * This code is specific to the OS400 implementation of the iconv library.
73 * CCSID 65535 (no conversion) is replaced by the ASCII CCSID.
74 * CCSID 0 is interpreted by the OS400 as the job's CCSID.
75 */
77 ccsid &= 0xFFFF;
79 if(ccsid == NOCONV_CCSID)
80 ccsid = ASCII_CCSID;
82 memset(buf, 0, ICONV_ID_SIZE);
83 curl_msprintf(buf, "IBMCCSID%05u0000000", ccsid);
86static iconv_t iconv_open_CCSID(unsigned int ccsidout, unsigned int ccsidin,
87 unsigned int cstr)
89 char fromcode[ICONV_ID_SIZE];
90 char tocode[ICONV_ID_SIZE];
92 /*
93 * Like iconv_open(), but character codes are given as CCSIDs.
94 * If `cstr' is non-zero, conversion is set up to stop whenever a
95 * null character is encountered.
96 * See iconv_open() IBM description in "National Language Support API".
97 */
99 makeOS400IconvCode(fromcode, ccsidin);
100 makeOS400IconvCode(tocode, ccsidout);
101 memset(tocode + 13, 0, sizeof(tocode) - 13); /* Dest. code id format. */
103 if(cstr)
104 fromcode[18] = '1'; /* Set null-terminator flag. */
106 return iconv_open(tocode, fromcode);
109static int convert(char *d, size_t dlen, const char *s, size_t slen,
110 unsigned int ccsidin, unsigned int ccsidout)
112 int i;
113 iconv_t cd;
114 size_t lslen;
116 /*
117 * Convert `ccsidin'-coded `slen'-data bytes at `s' into `ccsidout'-coded
118 * data stored in the `dlen'-byte buffer at `d'.
119 * If `slen' is CURL_ZERO_TERMINATED, let iconv() detect the end of
120 * input string.
121 * CCSID 65535 (no conversion) is replaced by the ASCII CCSID.
122 * Return the converted destination byte count, or -1 if error.
123 */
125 if(ccsidin == 65535)
126 ccsidin = ASCII_CCSID;
128 if(ccsidout == 65535)
129 ccsidout = ASCII_CCSID;
131 if(slen == CURL_ZERO_TERMINATED) {
132 lslen = 0;
133 cd = iconv_open_CCSID(ccsidout, ccsidin, 1);
134 }
135 else {
136 lslen = (size_t)slen;
137 cd = iconv_open_CCSID(ccsidout, ccsidin, 0);
138 }
140 if(ICONV_OPEN_ERROR(cd))
141 return -1;
143 i = dlen;
145 if((int)iconv(cd, (char **)&s, &lslen, &d, &dlen) < 0)
146 i = -1;
147 else
148 i -= dlen;
150 iconv_close(cd);
151 return i;
154static CURLcode dyn_addn_CCSID(struct dynbuf *db,
155 const void *mem, size_t len,
156 unsigned int ccsidin, unsigned int ccsidout)
158 iconv_t cd;
159 size_t dlen;
160 CURLcode result = CURLE_OK;
161 char buffer[128];
163 if(ccsidin == 65535)
164 ccsidin = ASCII_CCSID;
166 if(ccsidout == 65535)
167 ccsidout = ASCII_CCSID;
169 cd = iconv_open_CCSID(ccsidout, ccsidin, len == CURL_ZERO_TERMINATED);
171 if(ICONV_OPEN_ERROR(cd)) {
172 curlx_dyn_free(db);
173 return CURLE_NOT_BUILT_IN;
174 }
176 while(len) {
177 size_t dummylen = 0;
178 char *dptr = buffer;
179 int err = 0;
181 dlen = sizeof(buffer);
182 if((int)iconv(cd, (char **)&mem,
183 len == CURL_ZERO_TERMINATED ? &dummylen : &len, &dptr,
184 &dlen) < 0) {
185 /* !checksrc! disable ERRNOVAR 1 */
186 err = errno;
187 }
188 result = CURLE_BAD_FUNCTION_ARGUMENT;
189 switch(err) {
190 case 0:
191 case E2BIG:
192 break;
193 case ENOMEM:
194 result = CURLE_OUT_OF_MEMORY;
195 FALLTHROUGH();
196 default:
197 curlx_dyn_free(db);
198 iconv_close(cd);
199 return result;
200 }
202 result = curlx_dyn_addn(db, (const void *)buffer, dptr - buffer);
203 if(result) {
204 iconv_close(cd);
205 return result;
206 }
208 if(!err)
209 break;
210 }
212 iconv_close(cd);
213 dlen = curlx_dyn_len(db);
215 if(len == CURL_ZERO_TERMINATED) {
216 /* The null-terminator has been converted AND counted as a character.
217 * Measure it by an additional conversion and drop it. */
218 int tlen = convert(buffer, sizeof(buffer), universal_terminator, 1,
219 ASCII_CCSID, ccsidout);
221 if(tlen < 0 || tlen > dlen) {
222 curlx_dyn_free(db);
223 return CURLE_BAD_FUNCTION_ARGUMENT;
224 }
225 dlen -= tlen;
226 }
227 else {
228 /* Make sure the string is followed by an universal terminator. */
229 result = curlx_dyn_addn(db, universal_terminator,
230 sizeof(universal_terminator));
231 }
233 /* Restore the real string length. */
234 if(!result)
235 result = curlx_dyn_setlen(db, dlen);
237 return result;
240static struct curl_slist *slist_convert(struct curl_slist *from,
241 unsigned int ccsidin,
242 unsigned int ccsidout)
244 struct curl_slist *to = (struct curl_slist *)NULL;
245 struct dynbuf db;
246 size_t plen;
248 curlx_dyn_init(&db, MAX_CONV_EXPANSION * CURL_MAX_HTTP_HEADER);
250 for(; from; from = from->next) {
251 struct curl_slist *nl;
252 char *s;
254 if(dyn_addn_CCSID(&db, from->data, CURL_ZERO_TERMINATED,
255 ccsidin, ccsidout)) {
256 curl_slist_free_all(to);
257 return NULL;
258 }
259 s = curlx_dyn_take(&db, &plen);
260 nl = Curl_slist_append_nodup(to, s);
261 if(!nl) {
262 curl_slist_free_all(to);
263 untyped_free(s);
264 return NULL;
265 }
266 to = nl;
267 }
268 return to;
271static char *keyed_string(localkey_t key, const char *ascii,
272 unsigned int ccsid)
274 size_t len;
275 char *ebcdic;
276 struct dynbuf db;
278 if(!ascii)
279 return NULL;
281 curlx_dyn_init(&db, MAX_CONV_EXPANSION * CURL_MAX_INPUT_LENGTH);
282 if(dyn_addn_CCSID(&db, ascii, CURL_ZERO_TERMINATED, ASCII_CCSID, ccsid))
283 return NULL;
285 len = curlx_dyn_len(&db);
286 ebcdic = Curl_thread_buffer(key, len + sizeof(universal_terminator));
287 if(ebcdic) {
288 memcpy(ebcdic, curlx_dyn_ptr(&db), len);
289 memcpy(ebcdic + len, universal_terminator, sizeof(universal_terminator));
290 }
291 curlx_dyn_free(&db);
292 return ebcdic;
295const char *curl_to_ccsid(const char *string, unsigned int ccsid)
297 char *s = NULL;
299 if(string) {
300 struct dynbuf db;
301 size_t len;
303 curlx_dyn_init(&db, MAX_CONV_EXPANSION * CURL_MAX_INPUT_LENGTH);
304 dyn_addn_CCSID(&db, string, CURL_ZERO_TERMINATED, ASCII_CCSID, ccsid);
305 s = curlx_dyn_take(&db, &len);
306 }
308 return s;
311const char *curl_from_ccsid(const char *string, unsigned int ccsid)
313 char *s = NULL;
315 if(string) {
316 struct dynbuf db;
317 size_t len;
319 curlx_dyn_init(&db, CURL_MAX_INPUT_LENGTH);
320 dyn_addn_CCSID(&db, string, CURL_ZERO_TERMINATED, ccsid, ASCII_CCSID);
321 s = curlx_dyn_take(&db, &len);
322 }
324 return s;
327char *curl_version_ccsid(unsigned int ccsid)
329 return keyed_string(LK_CURL_VERSION, curl_version(), ccsid);
332char *curl_easy_escape_ccsid(CURL *handle, const char *string, int length,
333 unsigned int ccsidin, unsigned int ccsidout)
335 struct dynbuf db;
336 char *d;
337 size_t len;
339 if(!string)
340 return NULL;
342 curlx_dyn_init(&db, MAX_CONV_EXPANSION * CURL_MAX_INPUT_LENGTH);
344 if(dyn_addn_CCSID(&db, string, length ? length : CURL_ZERO_TERMINATED,
345 ccsidin, ASCII_CCSID))
346 return NULL;
348 d = curl_easy_escape(handle, curlx_dyn_ptr(&db), curlx_dyn_len(&db));
349 curlx_dyn_free(&db);
351 if(!d)
352 return NULL;
354 dyn_addn_CCSID(&db, d, CURL_ZERO_TERMINATED, ASCII_CCSID, ccsidout);
355 untyped_free(d);
356 return curlx_dyn_take(&db, &len);
359char *curl_easy_unescape_ccsid(CURL *handle, const char *string, int length,
360 int *outlength,
361 unsigned int ccsidin, unsigned int ccsidout)
363 struct dynbuf db;
364 char *d;
365 size_t len;
367 if(!string)
368 return NULL;
370 curlx_dyn_init(&db, MAX_CONV_EXPANSION * CURL_MAX_INPUT_LENGTH);
372 if(dyn_addn_CCSID(&db, string, length ? length : CURL_ZERO_TERMINATED,
373 ccsidin, ASCII_CCSID))
374 return NULL;
376 d = curl_easy_unescape(handle,
377 curlx_dyn_ptr(&db), curlx_dyn_len(&db), outlength);
378 curlx_dyn_free(&db);
380 if(!d)
381 return NULL;
383 if(!dyn_addn_CCSID(&db, d, CURL_ZERO_TERMINATED, ASCII_CCSID, ccsidout))
384 if(outlength)
385 *outlength = curlx_dyn_len(&db);
386 untyped_free(d);
387 return curlx_dyn_take(&db, &len);
390struct curl_slist *curl_slist_append_ccsid(struct curl_slist *list,
391 const char *data,
392 unsigned int ccsid)
394 const char *s;
396 if(!data)
397 return curl_slist_append(list, data);
399 s = curl_from_ccsid(data, ccsid);
401 if(!s)
402 return NULL;
404 list = Curl_slist_append_nodup(list, s);
405 if(!list)
406 untyped_free(s);
407 return list;
410time_t curl_getdate_ccsid(const char *p, const time_t *unused,
411 unsigned int ccsid)
413 const char *s;
414 time_t t;
416 if(!p)
417 return curl_getdate(p, unused);
419 s = curl_from_ccsid(p, ccsid);
421 if(!s)
422 return (time_t)-1;
424 t = curl_getdate(s, unused);
425 untyped_free(s);
426 return t;
429static int convert_version_info_string(const char **stringp, char **bufp,
430 int *left, unsigned int ccsid)
432 /* Helper for curl_version_info_ccsid(): convert a string if defined.
433 Result is stored in the `*left'-byte buffer at `*bufp'.
434 `*bufp' and `*left' are updated accordingly.
435 Return 0 if ok, else -1. */
437 if(*stringp) {
438 int l = convert(*bufp, *left, *stringp, CURL_ZERO_TERMINATED,
439 ASCII_CCSID, ccsid);
441 if(l <= 0)
442 return -1;
444 *stringp = *bufp;
445 *bufp += l;
446 *left -= l;
447 }
449 return 0;
452curl_version_info_data *curl_version_info_ccsid(CURLversion stamp,
453 unsigned int ccsid)
455 curl_version_info_data *p;
456 char *cp;
457 int n;
458 int nproto;
459 curl_version_info_data *id;
460 int i;
461 const char **cpp;
462 static const size_t charfields[] = {
463 offsetof(curl_version_info_data, version),
464 offsetof(curl_version_info_data, host),
465 offsetof(curl_version_info_data, ssl_version),
466 offsetof(curl_version_info_data, libz_version),
467 offsetof(curl_version_info_data, ares),
468 offsetof(curl_version_info_data, libidn),
469 offsetof(curl_version_info_data, libssh_version),
470 offsetof(curl_version_info_data, brotli_version),
471 offsetof(curl_version_info_data, nghttp2_version),
472 offsetof(curl_version_info_data, quic_version),
473 offsetof(curl_version_info_data, cainfo),
474 offsetof(curl_version_info_data, capath),
475 offsetof(curl_version_info_data, zstd_version),
476 offsetof(curl_version_info_data, hyper_version),
477 offsetof(curl_version_info_data, gsasl_version),
478 offsetof(curl_version_info_data, feature_names),
479 offsetof(curl_version_info_data, rtmp_version)
480 };
482 /* The assertion below is possible, because although the second operand
483 is an enum member, the first is a #define. In that case, the OS/400 C
484 compiler seems to compare string values after substitution. */
486#if CURLVERSION_NOW != CURLVERSION_ELEVENTH
487#error curl_version_info_data structure has changed: upgrade this procedure.
488#endif
490 /* If caller has been compiled with a newer version, error. */
492 if(stamp > CURLVERSION_NOW)
493 return NULL;
495 p = curl_version_info(stamp);
497 if(!p)
498 return p;
500 /* Measure thread space needed. */
502 n = 0;
503 nproto = 0;
505 if(p->protocols) {
506 while(p->protocols[nproto])
507 n += strlen(p->protocols[nproto++]);
509 n += nproto++;
510 }
512 for(i = 0; i < sizeof(charfields) / sizeof(charfields[0]); i++) {
513 cpp = (const char **)((char *)p + charfields[i]);
514 if(*cpp)
515 n += strlen(*cpp) + 1;
516 }
518 /* Allocate thread space. */
520 n *= MAX_CONV_EXPANSION;
522 if(nproto)
523 n += nproto * sizeof(const char *);
525 cp = Curl_thread_buffer(LK_VERSION_INFO_DATA, n);
526 id = (curl_version_info_data *)Curl_thread_buffer(LK_VERSION_INFO,
527 sizeof(*id));
529 if(!id || !cp)
530 return NULL;
532 /* Copy data and convert strings. */
534 memcpy(id, p, sizeof(*p));
536 if(id->protocols) {
537 i = nproto * sizeof(id->protocols[0]);
539 id->protocols = (const char * const *)cp;
540 memcpy(cp, (char *)p->protocols, i);
541 cp += i;
542 n -= i;
544 for(i = 0; id->protocols[i]; i++)
545 if(convert_version_info_string(((const char **)id->protocols) + i,
546 &cp, &n, ccsid))
547 return NULL;
548 }
550 for(i = 0; i < sizeof(charfields) / sizeof(charfields[0]); i++) {
551 cpp = (const char **)((char *)p + charfields[i]);
552 if(*cpp && convert_version_info_string(cpp, &cp, &n, ccsid))
553 return NULL;
554 }
556 return id;
559const char *curl_easy_strerror_ccsid(CURLcode error, unsigned int ccsid)
561 return keyed_string(LK_EASY_STRERROR, curl_easy_strerror(error), ccsid);
564const char *curl_share_strerror_ccsid(CURLSHcode error, unsigned int ccsid)
566 return keyed_string(LK_SHARE_STRERROR, curl_share_strerror(error), ccsid);
569const char *curl_multi_strerror_ccsid(CURLMcode error, unsigned int ccsid)
571 return keyed_string(LK_MULTI_STRERROR, curl_multi_strerror(error), ccsid);
574const char *curl_url_strerror_ccsid(CURLUcode error, unsigned int ccsid)
576 return keyed_string(LK_URL_STRERROR, curl_url_strerror(error), ccsid);
579void curl_certinfo_free_all(struct curl_certinfo *info)
581 /* Free all memory used by certificate info. */
582 if(info) {
583 if(info->certinfo) {
584 int i;
586 for(i = 0; i < info->num_of_certs; i++)
587 curl_slist_free_all(info->certinfo[i]);
588 untyped_free(info->certinfo);
589 }
590 untyped_free(info);
591 }
594CURLcode curl_easy_getinfo_ccsid(CURL *curl, CURLINFO info, ...)
596 va_list arg;
597 void *paramp;
598 CURLcode result;
599 struct Curl_easy *data;
601 /* WARNING: unlike curl_easy_getinfo(), the strings returned by this
602 procedure have to be free'ed. */
604 data = (struct Curl_easy *)curl;
605 va_start(arg, info);
606 paramp = va_arg(arg, void *);
607 result = Curl_getinfo(data, info, paramp);
609 if(result == CURLE_OK) {
610 unsigned int ccsid;
611 const char **cpp;
612 struct curl_slist **slp;
613 struct curl_certinfo *cipf;
614 struct curl_certinfo *cipt;
616 switch((int)info & CURLINFO_TYPEMASK) {
618 case CURLINFO_STRING:
619 ccsid = va_arg(arg, unsigned int);
620 cpp = (const char **)paramp;
622 if(*cpp) {
623 const char *s = curl_to_ccsid(*cpp, ccsid);
625 if(!s)
626 result = CURLE_OUT_OF_MEMORY;
627 else
628 *cpp = s;
629 }
631 break;
633 case CURLINFO_SLIST:
634 ccsid = va_arg(arg, unsigned int);
635 switch(info) {
636 case CURLINFO_CERTINFO:
637 cipf = *(struct curl_certinfo **)paramp;
638 if(cipf) {
639 cipt = curlx_malloc(sizeof(*cipt));
640 if(!cipt)
641 result = CURLE_OUT_OF_MEMORY;
642 else {
643 cipt->certinfo = curlx_calloc(cipf->num_of_certs + 1,
644 sizeof(struct curl_slist *));
645 if(!cipt->certinfo)
646 result = CURLE_OUT_OF_MEMORY;
647 else {
648 int i;
650 cipt->num_of_certs = cipf->num_of_certs;
651 for(i = 0; i < cipf->num_of_certs; i++)
652 if(cipf->certinfo[i]) {
653 cipt->certinfo[i] = slist_convert(cipf->certinfo[i],
654 ASCII_CCSID, ccsid);
655 if(!cipt->certinfo[i]) {
656 result = CURLE_OUT_OF_MEMORY;
657 break;
658 }
659 }
660 }
661 }
663 if(result != CURLE_OK) {
664 curl_certinfo_free_all(cipt);
665 cipt = NULL;
666 }
668 *(struct curl_certinfo **)paramp = cipt;
669 }
671 break;
673 case CURLINFO_TLS_SESSION:
674 case CURLINFO_TLS_SSL_PTR:
675 case CURLINFO_SOCKET:
676 break;
678 default:
679 slp = (struct curl_slist **)paramp;
680 if(*slp) {
681 *slp = slist_convert(*slp, ASCII_CCSID, ccsid);
682 if(!*slp)
683 result = CURLE_OUT_OF_MEMORY;
684 }
685 break;
686 }
687 }
688 }
690 va_end(arg);
691 return result;
694static int Curl_is_formadd_string(CURLformoption option)
696 switch(option) {
698 case CURLFORM_FILENAME:
699 case CURLFORM_CONTENTTYPE:
700 case CURLFORM_BUFFER:
701 case CURLFORM_FILE:
702 case CURLFORM_FILECONTENT:
703 case CURLFORM_COPYCONTENTS:
704 case CURLFORM_COPYNAME:
705 return 1;
706 }
708 return 0;
711static void Curl_formadd_release_local(struct curl_forms *forms, int nargs,
712 int skip)
714 while(nargs--)
715 if(nargs != skip)
716 if(Curl_is_formadd_string(forms[nargs].option))
717 if(forms[nargs].value)
718 untyped_free(forms[nargs].value);
720 untyped_free(forms);
723static int Curl_formadd_convert(struct curl_forms *forms, int formx,
724 int lengthx, unsigned int ccsid)
726 size_t len = CURL_ZERO_TERMINATED;
727 char *cp;
728 struct dynbuf db;
730 if(formx < 0 || !forms[formx].value)
731 return 0;
733 curlx_dyn_init(&db, CURL_MAX_INPUT_LENGTH);
735 if(lengthx >= 0)
736 len = (size_t)forms[lengthx].value;
738 if(dyn_addn_CCSID(&db, forms[formx].value, len, ccsid, ASCII_CCSID))
739 return -1;
741 cp = curlx_dyn_take(&db, &len);
742 forms[formx].value = cp;
744 if(lengthx >= 0)
745 forms[lengthx].value = (char *)len; /* Update length after conversion. */
747 return len;
750CURLFORMcode curl_formadd_ccsid(struct curl_httppost **httppost,
751 struct curl_httppost **last_post, ...)
753 va_list arg;
754 CURLformoption option;
755 CURLFORMcode result;
756 struct curl_forms *forms;
757 struct curl_forms *lforms;
758 struct curl_forms *tforms;
759 unsigned int lformlen;
760 const char *value;
761 unsigned int ccsid;
762 int nargs;
763 int namex;
764 int namelengthx;
765 int contentx;
766 int lengthx;
767 unsigned int contentccsid;
768 unsigned int nameccsid;
770 /* A single curl_formadd() call cannot be split in several calls to deal
771 with all parameters: the original parameters are thus copied to a local
772 curl_forms array and converted to ASCII when needed.
773 CURLFORM_PTRNAME is processed as if it were CURLFORM_COPYNAME.
774 CURLFORM_COPYNAME and CURLFORM_NAMELENGTH occurrence order in
775 parameters is not defined; for this reason, the actual conversion is
776 delayed to the end of parameter processing. The same applies to
777 CURLFORM_COPYCONTENTS/CURLFORM_CONTENTSLENGTH, but these may appear
778 several times in the parameter list; the problem resides here in knowing
779 which CURLFORM_CONTENTSLENGTH applies to which CURLFORM_COPYCONTENTS and
780 when we can be sure to have both info for conversion: end of parameter
781 list is such a point, but CURLFORM_CONTENTTYPE is also used here as a
782 natural separator between content data definitions; this seems to be
783 in accordance with FormAdd() behavior. */
785 /* Allocate the local curl_forms array. */
787 lformlen = ALLOC_GRANULE;
788 lforms = curlx_malloc(lformlen * sizeof(*lforms));
790 if(!lforms)
791 return CURL_FORMADD_MEMORY;
793 /* Process the arguments, copying them into local array, latching conversion
794 indexes and converting when needed. */
796 result = CURL_FORMADD_OK;
797 nargs = 0;
798 contentx = -1;
799 lengthx = -1;
800 namex = -1;
801 namelengthx = -1;
802 forms = NULL;
803 va_start(arg, last_post);
805 for(;;) {
806 /* Make sure there is still room for an item in local array. */
808 if(nargs >= lformlen) {
809 lformlen += ALLOC_GRANULE;
810 tforms = curlx_realloc(lforms, lformlen * sizeof(*lforms));
812 if(!tforms) {
813 result = CURL_FORMADD_MEMORY;
814 break;
815 }
817 lforms = tforms;
818 }
820 /* Get next option. */
822 if(forms) {
823 /* Get option from array. */
825 option = forms->option;
826 value = forms->value;
827 forms++;
828 }
829 else {
830 /* Get option from arguments. */
832 option = va_arg(arg, CURLformoption);
834 if(option == CURLFORM_END)
835 break;
836 }
838 /* Dispatch by option. */
840 switch(option) {
842 case CURLFORM_END:
843 forms = NULL; /* Leave array mode. */
844 continue;
846 case CURLFORM_ARRAY:
847 if(!forms) {
848 forms = va_arg(arg, struct curl_forms *);
849 continue;
850 }
852 result = CURL_FORMADD_ILLEGAL_ARRAY;
853 break;
855 case CURLFORM_COPYNAME:
856 option = CURLFORM_PTRNAME; /* Static for now. */
858 case CURLFORM_PTRNAME:
859 if(namex >= 0)
860 result = CURL_FORMADD_OPTION_TWICE;
862 namex = nargs;
864 if(!forms) {
865 value = va_arg(arg, char *);
866 nameccsid = (unsigned int)va_arg(arg, long);
867 }
868 else {
869 nameccsid = (unsigned int)forms->value;
870 forms++;
871 }
873 break;
875 case CURLFORM_COPYCONTENTS:
876 if(contentx >= 0)
877 result = CURL_FORMADD_OPTION_TWICE;
879 contentx = nargs;
881 if(!forms) {
882 value = va_arg(arg, char *);
883 contentccsid = (unsigned int)va_arg(arg, long);
884 }
885 else {
886 contentccsid = (unsigned int)forms->value;
887 forms++;
888 }
890 break;
892 case CURLFORM_PTRCONTENTS:
893 case CURLFORM_BUFFERPTR:
894 if(!forms)
895 value = va_arg(arg, char *); /* No conversion. */
897 break;
899 case CURLFORM_CONTENTSLENGTH:
900 lengthx = nargs;
902 if(!forms)
903 value = (char *)va_arg(arg, long);
905 break;
907 case CURLFORM_CONTENTLEN:
908 lengthx = nargs;
910 if(!forms)
911 value = (char *)va_arg(arg, curl_off_t);
913 break;
915 case CURLFORM_NAMELENGTH:
916 namelengthx = nargs;
918 if(!forms)
919 value = (char *)va_arg(arg, long);
921 break;
923 case CURLFORM_BUFFERLENGTH:
924 if(!forms)
925 value = (char *)va_arg(arg, long);
927 break;
929 case CURLFORM_CONTENTHEADER:
930 if(!forms)
931 value = (char *)va_arg(arg, struct curl_slist *);
933 break;
935 case CURLFORM_STREAM:
936 if(!forms)
937 value = (char *)va_arg(arg, void *);
939 break;
941 case CURLFORM_CONTENTTYPE:
942 /* If a previous content has been encountered, convert it now. */
944 if(Curl_formadd_convert(lforms, contentx, lengthx, contentccsid) < 0) {
945 result = CURL_FORMADD_MEMORY;
946 break;
947 }
949 contentx = -1;
950 lengthx = -1;
951 /* Fall into default. */
953 default:
954 /* Must be a convertible string. */
956 if(!Curl_is_formadd_string(option)) {
957 result = CURL_FORMADD_UNKNOWN_OPTION;
958 break;
959 }
961 if(!forms) {
962 value = va_arg(arg, char *);
963 ccsid = (unsigned int)va_arg(arg, long);
964 }
965 else {
966 ccsid = (unsigned int)forms->value;
967 forms++;
968 }
970 /* Do the conversion. */
972 lforms[nargs].value = value;
974 if(Curl_formadd_convert(lforms, nargs, -1, ccsid) < 0) {
975 result = CURL_FORMADD_MEMORY;
976 break;
977 }
979 value = lforms[nargs].value;
980 }
982 if(result != CURL_FORMADD_OK)
983 break;
985 lforms[nargs].value = value;
986 lforms[nargs++].option = option;
987 }
989 va_end(arg);
991 /* Convert the name and the last content, now that we know their lengths. */
993 if(result == CURL_FORMADD_OK && namex >= 0) {
994 if(Curl_formadd_convert(lforms, namex, namelengthx, nameccsid) < 0)
995 result = CURL_FORMADD_MEMORY;
996 else
997 lforms[namex].option = CURLFORM_COPYNAME; /* Force copy. */
998 }
1000 if(result == CURL_FORMADD_OK) {
1001 if(Curl_formadd_convert(lforms, contentx, lengthx, contentccsid) < 0)
1002 result = CURL_FORMADD_MEMORY;
1003 else
1004 contentx = -1;
1007 /* Do the formadd with our converted parameters. */
1009 if(result == CURL_FORMADD_OK) {
1010 lforms[nargs].option = CURLFORM_END;
1011 result = curl_formadd(httppost, last_post,
1012 CURLFORM_ARRAY, lforms, CURLFORM_END);
1015 /* Terminate. */
1017 Curl_formadd_release_local(lforms, nargs, contentx);
1018 return result;
1021struct cfcdata {
1022 curl_formget_callback append;
1023 void *arg;
1024 unsigned int ccsid;
1027static size_t formget_callback_ccsid(void *arg, const char *buf, size_t len)
1029 struct cfcdata *p;
1030 size_t olen;
1031 size_t ret;
1032 struct dynbuf db;
1034 p = (struct cfcdata *)arg;
1036 if((long)len <= 0)
1037 return p->append(p->arg, buf, len);
1039 curlx_dyn_init(&db, MAX_CONV_EXPANSION * CURL_MAX_INPUT_LENGTH);
1041 if(dyn_addn_CCSID(&db, buf, len, ASCII_CCSID, p->ccsid))
1042 return (size_t)-1;
1044 olen = curlx_dyn_len(&db);
1045 ret = p->append(p->arg, curlx_dyn_ptr(&db), olen);
1046 curlx_dyn_free(&db);
1047 return ret == olen ? len : -1;
1050int curl_formget_ccsid(struct curl_httppost *form, void *arg,
1051 curl_formget_callback append, unsigned int ccsid)
1053 struct cfcdata lcfc;
1055 lcfc.append = append;
1056 lcfc.arg = arg;
1057 lcfc.ccsid = ccsid;
1058 return curl_formget(form, (void *)&lcfc, formget_callback_ccsid);
1061CURLcode curl_easy_setopt_ccsid(CURL *curl, CURLoption tag, ...)
1063 CURLcode result;
1064 va_list arg;
1065 const char *s;
1066 unsigned int ccsid;
1067 struct dynbuf db;
1068 curl_off_t pfsize;
1069 size_t len;
1070 struct Curl_easy *data = curl;
1072 curlx_dyn_init(&db, CURL_MAX_INPUT_LENGTH);
1073 va_start(arg, tag);
1075 switch(tag) {
1077 /* BEGIN TRANSLATABLE STRING OPTIONS */
1078 /* Keep option symbols in alphanumeric order and retain the BEGIN/END
1079 armor comments. */
1080 case CURLOPT_ABSTRACT_UNIX_SOCKET:
1081 case CURLOPT_ACCEPT_ENCODING:
1082 case CURLOPT_ALTSVC:
1083 case CURLOPT_AWS_SIGV4:
1084 case CURLOPT_CAINFO:
1085 case CURLOPT_CAPATH:
1086 case CURLOPT_COOKIE:
1087 case CURLOPT_COOKIEFILE:
1088 case CURLOPT_COOKIEJAR:
1089 case CURLOPT_COOKIELIST:
1090 case CURLOPT_CRLFILE:
1091 case CURLOPT_CUSTOMREQUEST:
1092 case CURLOPT_DEFAULT_PROTOCOL:
1093 case CURLOPT_DNS_INTERFACE:
1094 case CURLOPT_DNS_LOCAL_IP4:
1095 case CURLOPT_DNS_LOCAL_IP6:
1096 case CURLOPT_DNS_SERVERS:
1097 case CURLOPT_DOH_URL:
1098 case CURLOPT_ECH:
1099 case CURLOPT_EGDSOCKET:
1100 case CURLOPT_FTPPORT:
1101 case CURLOPT_FTP_ACCOUNT:
1102 case CURLOPT_FTP_ALTERNATIVE_TO_USER:
1103 case CURLOPT_HAPROXY_CLIENT_IP:
1104 case CURLOPT_HSTS:
1105 case CURLOPT_HTTPSIG_HEADERS:
1106 case CURLOPT_HTTPSIG_KEY:
1107 case CURLOPT_HTTPSIG_KEYID:
1108 case CURLOPT_INTERFACE:
1109 case CURLOPT_ISSUERCERT:
1110 case CURLOPT_KEYPASSWD:
1111 case CURLOPT_KRBLEVEL:
1112 case CURLOPT_LOGIN_OPTIONS:
1113 case CURLOPT_MAIL_AUTH:
1114 case CURLOPT_MAIL_FROM:
1115 case CURLOPT_NETRC_FILE:
1116 case CURLOPT_NOPROXY:
1117 case CURLOPT_PASSWORD:
1118 case CURLOPT_PINNEDPUBLICKEY:
1119 case CURLOPT_PRE_PROXY:
1120 case CURLOPT_PROTOCOLS_STR:
1121 case CURLOPT_PROXY:
1122 case CURLOPT_PROXYPASSWORD:
1123 case CURLOPT_PROXYUSERNAME:
1124 case CURLOPT_PROXYUSERPWD:
1125 case CURLOPT_PROXY_CAINFO:
1126 case CURLOPT_PROXY_CAPATH:
1127 case CURLOPT_PROXY_CRLFILE:
1128 case CURLOPT_PROXY_ISSUERCERT:
1129 case CURLOPT_PROXY_KEYPASSWD:
1130 case CURLOPT_PROXY_PINNEDPUBLICKEY:
1131 case CURLOPT_PROXY_SERVICE_NAME:
1132 case CURLOPT_PROXY_SSLCERT:
1133 case CURLOPT_PROXY_SSLCERTTYPE:
1134 case CURLOPT_PROXY_SSLKEY:
1135 case CURLOPT_PROXY_SSLKEYTYPE:
1136 case CURLOPT_PROXY_SSL_CIPHER_LIST:
1137 case CURLOPT_PROXY_TLS13_CIPHERS:
1138 case CURLOPT_PROXY_TLSAUTH_PASSWORD:
1139 case CURLOPT_PROXY_TLSAUTH_TYPE:
1140 case CURLOPT_PROXY_TLSAUTH_USERNAME:
1141 case CURLOPT_RANDOM_FILE:
1142 case CURLOPT_RANGE:
1143 case CURLOPT_REDIR_PROTOCOLS_STR:
1144 case CURLOPT_REFERER:
1145 case CURLOPT_REQUEST_TARGET:
1146 case CURLOPT_RTSP_SESSION_ID:
1147 case CURLOPT_RTSP_STREAM_URI:
1148 case CURLOPT_RTSP_TRANSPORT:
1149 case CURLOPT_SASL_AUTHZID:
1150 case CURLOPT_SERVICE_NAME:
1151 case CURLOPT_SOCKS5_GSSAPI_SERVICE:
1152 case CURLOPT_SSH_HOST_PUBLIC_KEY_MD5:
1153 case CURLOPT_SSH_HOST_PUBLIC_KEY_SHA256:
1154 case CURLOPT_SSH_KNOWNHOSTS:
1155 case CURLOPT_SSH_PRIVATE_KEYFILE:
1156 case CURLOPT_SSH_PUBLIC_KEYFILE:
1157 case CURLOPT_SSLCERT:
1158 case CURLOPT_SSLCERTTYPE:
1159 case CURLOPT_SSLENGINE:
1160 case CURLOPT_SSLKEY:
1161 case CURLOPT_SSLKEYTYPE:
1162 case CURLOPT_SSL_CIPHER_LIST:
1163 case CURLOPT_SSL_EC_CURVES:
1164 case CURLOPT_SSL_SIGNATURE_ALGORITHMS:
1165 case CURLOPT_TLS13_CIPHERS:
1166 case CURLOPT_TLSAUTH_PASSWORD:
1167 case CURLOPT_TLSAUTH_TYPE:
1168 case CURLOPT_TLSAUTH_USERNAME:
1169 case CURLOPT_UNIX_SOCKET_PATH:
1170 case CURLOPT_URL:
1171 case CURLOPT_USERAGENT:
1172 case CURLOPT_USERNAME:
1173 case CURLOPT_USERPWD:
1174 case CURLOPT_XOAUTH2_BEARER:
1175 /* END TRANSLATABLE STRING OPTIONS */
1176 s = va_arg(arg, const char *);
1177 ccsid = va_arg(arg, unsigned int);
1179 if(s) {
1180 s = curl_from_ccsid(s, ccsid);
1182 if(!s) {
1183 result = CURLE_OUT_OF_MEMORY;
1184 break;
1188 result = curl_easy_setopt(curl, tag, s);
1189 untyped_free(s);
1190 break;
1192 case CURLOPT_COPYPOSTFIELDS:
1193 /* Special case: byte count may have been given by CURLOPT_POSTFIELDSIZE
1194 prior to this call. In this case, convert the given byte count and
1195 replace the length according to the conversion result. */
1196 s = va_arg(arg, const char *);
1197 ccsid = va_arg(arg, unsigned int);
1199 pfsize = data->set.postfieldsize;
1201 if(!s || !pfsize || ccsid == NOCONV_CCSID || ccsid == ASCII_CCSID) {
1202 result = curl_easy_setopt(curl, CURLOPT_COPYPOSTFIELDS, s);
1203 break;
1206 if(pfsize == -1)
1207 result = dyn_addn_CCSID(&db, s, CURL_ZERO_TERMINATED,
1208 ccsid, ASCII_CCSID);
1209 else {
1210 /* Data length specified. */
1211 if(pfsize < 0 || pfsize > SIZE_MAX)
1212 result = CURLE_OUT_OF_MEMORY;
1213 else
1214 result = dyn_addn_CCSID(&db, s, (size_t)pfsize, ccsid, ASCII_CCSID);
1217 if(result)
1218 break;
1220 s = curlx_dyn_take(&db, &len);
1222 /* The following lines give data ownership to the library without
1223 copying them. */
1224 result = curl_easy_setopt(curl, CURLOPT_POSTFIELDS, s);
1225 if(!result) {
1226 data->set.str_copypostfields = CURL_UNCONST(s); /* Adopt. */
1227 if(pfsize != -1)
1228 data->set.postfieldsize = len;
1230 else
1231 untyped_free(s);
1233 break;
1235 default:
1236 if(tag / 10000 == CURLOPTTYPE_BLOB) {
1237 struct curl_blob *bp = va_arg(arg, struct curl_blob *);
1238 struct curl_blob blob;
1240 ccsid = va_arg(arg, unsigned int);
1242 if(bp && bp->data && bp->len &&
1243 ccsid != NOCONV_CCSID && ccsid != ASCII_CCSID) {
1244 result = dyn_addn_CCSID(&db, bp->data, bp->len, ccsid, ASCII_CCSID);
1245 if(result)
1246 break;
1248 blob.data = curlx_dyn_ptr(&db);
1249 blob.len = curlx_dyn_len(&db);
1250 blob.flags = bp->flags | CURL_BLOB_COPY;
1251 bp = &blob;
1253 result = curl_easy_setopt(curl, tag, bp);
1254 break;
1256 FALLTHROUGH();
1257 case CURLOPT_ERRORBUFFER: /* This is an output buffer. */
1258 result = Curl_vsetopt(curl, tag, arg);
1259 break;
1262 va_end(arg);
1263 curlx_dyn_free(&db);
1264 return result;
1267/* ILE/RPG helper functions. */
1269char *curl_form_long_value(long value)
1271 /* ILE/RPG cannot cast an integer to a pointer. This procedure does it.
1272 As OS/400 is unable to dereference a pointer built from an integer only,
1273 the goal here is only to keep the integer value as a (invalid) pointer
1274 for a later reverse conversion. */
1276 return (char *)value;
1279CURLcode curl_easy_setopt_RPGnum_(CURL *easy, CURLoption tag, curl_off_t arg)
1281 /* ILE/RPG procedure overloading cannot discriminate between different
1282 size and/or signedness of format arguments. This provides a generic
1283 wrapper that adapts size to the given tag expectation.
1284 This procedure is not intended to be explicitly called from user code. */
1285 if(tag / 10000 != CURLOPTTYPE_OFF_T)
1286 return curl_easy_setopt(easy, tag, (long)arg);
1287 return curl_easy_setopt(easy, tag, arg);
1290CURLcode curl_multi_setopt_RPGnum_(CURLM *multi, CURLMoption tag,
1291 curl_off_t arg)
1293 /* Likewise, for multi handle. */
1294 if(tag / 10000 != CURLOPTTYPE_OFF_T)
1295 return curl_multi_setopt(multi, tag, (long)arg);
1296 return curl_multi_setopt(multi, tag, arg);
1299char *curl_pushheader_bynum_cssid(struct curl_pushheaders *h, size_t num,
1300 unsigned int ccsid)
1302 return CURL_UNCONST(curl_to_ccsid(curl_pushheader_bynum(h, num), ccsid));
1305char *curl_pushheader_byname_ccsid(struct curl_pushheaders *h,
1306 const char *header, unsigned int ccsidin,
1307 unsigned int ccsidout)
1309 const char *d = NULL;
1311 if(header) {
1312 const char *hdr = curl_from_ccsid(header, ccsidin);
1314 if(hdr) {
1315 char *s = curl_pushheader_byname(h, hdr);
1317 untyped_free(hdr);
1319 if(s)
1320 d = curl_to_ccsid(s, ccsidout);
1324 return CURL_UNCONST(d);
1327static CURLcode mime_string_call(curl_mimepart *part, const char *string,
1328 unsigned int ccsid,
1329 CURLcode (*mimefunc)(curl_mimepart *part,
1330 const char *string))
1332 const char *s;
1333 CURLcode result;
1335 if(!string)
1336 return mimefunc(part, string);
1337 s = curl_from_ccsid(string, ccsid);
1338 if(!s)
1339 return CURLE_OUT_OF_MEMORY;
1341 result = mimefunc(part, s);
1342 untyped_free(s);
1343 return result;
1346CURLcode curl_mime_name_ccsid(curl_mimepart *part, const char *name,
1347 unsigned int ccsid)
1349 return mime_string_call(part, name, ccsid, curl_mime_name);
1352CURLcode curl_mime_filename_ccsid(curl_mimepart *part, const char *filename,
1353 unsigned int ccsid)
1355 return mime_string_call(part, filename, ccsid, curl_mime_filename);
1358CURLcode curl_mime_type_ccsid(curl_mimepart *part, const char *mimetype,
1359 unsigned int ccsid)
1361 return mime_string_call(part, mimetype, ccsid, curl_mime_type);
1364CURLcode curl_mime_encoder_ccsid(curl_mimepart *part, const char *encoding,
1365 unsigned int ccsid)
1367 return mime_string_call(part, encoding, ccsid, curl_mime_encoder);
1370CURLcode curl_mime_filedata_ccsid(curl_mimepart *part, const char *filename,
1371 unsigned int ccsid)
1373 return mime_string_call(part, filename, ccsid, curl_mime_filedata);
1376CURLcode curl_mime_data_ccsid(curl_mimepart *part, const char *data,
1377 size_t datasize, unsigned int ccsid)
1379 struct dynbuf db;
1380 CURLcode result;
1382 if(!data)
1383 return curl_mime_data(part, data, datasize);
1385 curlx_dyn_init(&db, CURL_MAX_INPUT_LENGTH);
1387 result = dyn_addn_CCSID(&db, data, datasize, ccsid, ASCII_CCSID);
1389 if(!result) {
1390 size_t osize;
1391 char *newdata = curlx_dyn_take(&db, &osize);
1393 result = curl_mime_data(part, newdata, datasize == CURL_ZERO_TERMINATED ?
1394 datasize : osize);
1395 untyped_free(newdata);
1398 return result;
1401CURLUcode curl_url_get_ccsid(CURLU *handle, CURLUPart what, char **part,
1402 unsigned int flags, unsigned int ccsid)
1404 char *s = NULL;
1405 CURLUcode result;
1407 if(!part)
1408 return CURLUE_BAD_PARTPOINTER;
1410 *part = NULL;
1411 result = curl_url_get(handle, what, &s, flags);
1412 if(result == CURLUE_OK) {
1413 if(s) {
1414 const char *d = curl_to_ccsid(s, ccsid);
1416 if(d)
1417 *part = CURL_UNCONST(d);
1418 else
1419 result = CURLUE_OUT_OF_MEMORY;
1422 if(s)
1423 untyped_free(s);
1424 return result;
1427CURLUcode curl_url_set_ccsid(CURLU *handle, CURLUPart what, const char *part,
1428 unsigned int flags, unsigned int ccsid)
1430 const char *s = NULL;
1431 CURLUcode result;
1433 if(part) {
1434 s = curl_from_ccsid(part, ccsid);
1435 if(!s)
1436 return CURLUE_OUT_OF_MEMORY;
1438 result = curl_url_set(handle, what, s, flags);
1439 if(s)
1440 untyped_free(s);
1441 return result;
1444const struct curl_easyoption *curl_easy_option_by_name_ccsid(
1445 const char *name, unsigned int ccsid)
1447 const struct curl_easyoption *option = NULL;
1449 if(name) {
1450 const char *s = curl_from_ccsid(name, ccsid);
1452 if(s) {
1453 option = curl_easy_option_by_name(s);
1454 untyped_free(s);
1458 return option;
1461/* Return option name in the given ccsid. */
1462const char *curl_easy_option_get_name_ccsid(
1463 const struct curl_easyoption *option, unsigned int ccsid)
1465 const char *name = NULL;
1467 if(option && option->name)
1468 name = curl_to_ccsid(option->name, ccsid);
1470 return name;
1473/* Header API CCSID support. */
1474CURLHcode curl_easy_header_ccsid(CURL *easy, const char *name, size_t index,
1475 unsigned int origin, int request,
1476 struct curl_header **hout, unsigned int ccsid)
1478 CURLHcode result = CURLHE_BAD_ARGUMENT;
1480 if(name) {
1481 const char *s = curl_from_ccsid(name, ccsid);
1483 result = CURLHE_OUT_OF_MEMORY;
1484 if(s) {
1485 result = curl_easy_header(easy, s, index, origin, request, hout);
1486 untyped_free(s);
1490 return result;
Diagnostics4 git calls · 30 ms
CallStatusSizeTime030 ms
discover200152 B3 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=152
git.server.agent=gitty/1.0
git.server.object_format=sha1
git.server.caps=agent ls-refs fetch object-format
git.server.fetch=shallow filter sideband-all
git.protocol.version=2
git.pkt.frames=8
git.pkt.data=6
git.pkt.flush=2
git.pkt.delim=0
git.pkt.bytes=152
git.pkt.payload.max=34
ls-refs200149 B · hit3 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=3
git.response.bytes=149
git.response.cache=HIT
git.response.duration_ms=3
git.protocol.version=2
git.pkt.frames=3
git.pkt.data=2
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=149
git.pkt.payload.max=78
git.ls_refs.count=2
git.ls_refs.head=refs/heads/master
fetchblob:none · deepen 10200287 KiB · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=25
git.response.bytes=293470
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=blob:none
git.fetch.filter.requested=tree:0
git.fetch.filter.fallback=blob:none
git.fetch.filter.learned=false
git.fetch.wants=31c911efe5652725e930f4d2e60c9060e5f6646d
git.fetch.haves.count=0
git.fetch.deepen=10
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=10
git.pkt.data=8
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=293470
git.pkt.payload.max=65516
git.sideband.band1.bytes=293354
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=87
git.pack.bytes=293354
git.pack.ofs_delta=0
git.pack.ref_delta=1
git.pack.chain.max=1
git.pack.trailer=6a646bcda6740bab42e321b51998b52ea15146c0
git.pack.full=86
Open pack map
fetch20011 KiB · hit25 ms
git.upload-pack fetch
http.response.status_code=200
git.response.bytes=10908
git.response.cache=HIT
git.response.duration_ms=25
git.fetch.wants=2ee4d71eafc56119127658d5d0a96808767cd7eb
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=3
git.pkt.data=2
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=10908
git.pkt.payload.max=10887
git.sideband.band1.bytes=10886
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0

Each row is one HTTP round trip ply made to the git server for this page, on one timeline. discover asks what the server speaks, ls-refs lists branch tips, fetch brings objects by id. A hit was served by Workers Cache. Tap a row for its wire details.

Remote
https://5ad2236b39de4c8bd8f6270ea63f3ea9.artifacts.cloudflare.net/git/public-v0/curl.git
Ref
refs/heads/master
Commit
31c911efe5652725e930f4d2e60c9060e5f6646d
cf-ray
a5e2f63618033a24
Request
2b7e0ac9…
Protocol
v2 · sha1
Agent
gitty/1.0
Filter
advertised
Fetch
shallow filter sideband-all
Capabilities
agent ls-refs fetch object-format