Artifactspublic-v0

curl

master
ply4 git calls31 ms293 KiB3 cachedprotocol v2
1036 lines24 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/* OS/400 additional support. */
28#include <curl/curl.h>
29#include "config-os400.h" /* Not curl_setup.h: we only need some defines. */
31#include <sys/un.h>
33#include <stdlib.h>
34#include <stddef.h>
35#include <string.h>
36#include <pthread.h>
37#include <netdb.h>
38#include <qadrt.h>
39#include <errno.h>
41#ifdef HAVE_LIBZ
42#include <zlib.h>
43#endif
45#ifdef HAVE_GSSAPI
46#include <gssapi.h>
47#endif
49#ifndef CURL_DISABLE_LDAP
50#include <ldap.h>
51#endif
53#include <netinet/in.h>
54#include <arpa/inet.h>
56#include "os400sys.h"
58/*
59 * QADRT OS/400 ASCII runtime defines only the most used procedures, but a
60 * lot of them are not supported. This module implements ASCII wrappers for
61 * those that are used by libcurl, but not defined by QADRT.
62 */
64#pragma convert(0) /* Restore EBCDIC. */
66#define MIN_BYTE_GAIN 1024 /* Minimum gain when shortening a buffer. */
68struct buffer_t {
69 unsigned long size; /* Buffer size. */
70 char *buf; /* Buffer address. */
71};
73static char *buffer_undef(localkey_t key, long size);
74static char *buffer_threaded(localkey_t key, long size);
75static char *buffer_unthreaded(localkey_t key, long size);
77static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
78static pthread_key_t thdkey;
79static struct buffer_t *locbufs;
81char *(*Curl_thread_buffer)(localkey_t key, long size) = buffer_undef;
83static void thdbufdestroy(void *private)
85 if(private) {
86 struct buffer_t *p = (struct buffer_t *)private;
87 localkey_t i;
89 for(i = (localkey_t)0; i < LK_LAST; i++) {
90 free(p->buf);
91 p++;
92 }
94 free(private);
95 }
98static void terminate(void)
100 if(Curl_thread_buffer == buffer_threaded) {
101 locbufs = pthread_getspecific(thdkey);
102 pthread_setspecific(thdkey, (void *)NULL);
103 pthread_key_delete(thdkey);
104 }
106 if(Curl_thread_buffer != buffer_undef) {
107 thdbufdestroy((void *)locbufs);
108 locbufs = (struct buffer_t *)NULL;
109 }
111 Curl_thread_buffer = buffer_undef;
114static char *get_buffer(struct buffer_t *buf, long size)
116 char *cp;
118 /* If `size' >= 0, make sure buffer at `buf' is at least `size'-byte long.
119 Return the buffer address. */
121 if(size < 0)
122 return buf->buf;
124 if(!buf->buf) {
125 buf->buf = malloc(size);
126 if(buf->buf)
127 buf->size = size;
129 return buf->buf;
130 }
132 if((unsigned long)size <= buf->size) {
133 /* Shorten the buffer only if it frees a significant byte count. This
134 avoids some realloc() overhead. */
136 if(buf->size - size < MIN_BYTE_GAIN)
137 return buf->buf;
138 }
140 /* Resize the buffer. */
142 cp = realloc(buf->buf, size);
143 if(cp) {
144 buf->buf = cp;
145 buf->size = size;
146 }
147 else if(size <= buf->size)
148 cp = buf->buf;
150 return cp;
153/*
154 * Get buffer address for the given local key.
155 * This is always called though `Curl_thread_buffer' and when threads are
156 * NOT made available by the os, so no mutex lock/unlock occurs.
157 */
158static char *buffer_unthreaded(localkey_t key, long size)
160 return get_buffer(locbufs + key, size);
163/*
164 * Get buffer address for the given local key, taking care of
165 * concurrent threads.
166 * This is always called though `Curl_thread_buffer' and when threads are
167 * made available by the os.
168 */
169static char *buffer_threaded(localkey_t key, long size)
171 struct buffer_t *bufs;
173 /* Get the buffer for the given local key in the current thread, and
174 make sure it is at least `size'-byte long. Set `size' to < 0 to get
175 its address only. */
177 bufs = (struct buffer_t *)pthread_getspecific(thdkey);
179 if(!bufs) {
180 if(size < 0)
181 return (char *)NULL; /* No buffer yet. */
183 /* Allocate buffer descriptors for the current thread. */
185 bufs = calloc((size_t)LK_LAST, sizeof(*bufs));
186 if(!bufs)
187 return (char *)NULL;
189 if(pthread_setspecific(thdkey, (void *)bufs)) {
190 free(bufs);
191 return (char *)NULL;
192 }
193 }
195 return get_buffer(bufs + key, size);
198static char *buffer_undef(localkey_t key, long size)
200 /* Define the buffer system, get the buffer for the given local key in
201 the current thread, and make sure it is at least `size'-byte long.
202 Set `size' to < 0 to get its address only. */
204 pthread_mutex_lock(&mutex);
206 /* Determine if we can use pthread-specific data. */
208 if(Curl_thread_buffer == buffer_undef) { /* If unchanged during lock. */
209 /* OS400 interactive jobs do not support threads: check here. */
210 if(!pthread_key_create(&thdkey, thdbufdestroy)) {
211 /* Threads are supported: use the thread-aware buffer procedure. */
212 Curl_thread_buffer = buffer_threaded;
213 }
214 else {
215 /* No multi-threading available: allocate storage for single-thread
216 * buffer headers. */
217 locbufs = calloc((size_t)LK_LAST, sizeof(*locbufs));
218 if(!locbufs) {
219 pthread_mutex_unlock(&mutex); /* For symmetry: will probably fail. */
220 return (char *)NULL;
221 }
222 else
223 Curl_thread_buffer = buffer_unthreaded; /* Use unthreaded version. */
224 }
226 atexit(terminate);
227 }
229 pthread_mutex_unlock(&mutex);
230 return Curl_thread_buffer(key, size);
233static char *set_thread_string(localkey_t key, const char *s)
235 int i;
236 char *cp;
238 if(!s)
239 return (char *)NULL;
241 i = strlen(s) + 1;
242 cp = Curl_thread_buffer(key, MAX_CONV_EXPANSION * i + 1);
244 if(cp) {
245 i = QadrtConvertE2A(cp, s, MAX_CONV_EXPANSION * i, i);
246 cp[i] = '\0';
247 }
249 return cp;
252int Curl_getnameinfo_a(const struct sockaddr *sa, socklen_t salen,
253 char *nodename, socklen_t nodenamelen,
254 char *servname, socklen_t servnamelen,
255 int flags)
257 char *enodename = NULL;
258 char *eservname = NULL;
259 int status;
261 if(nodename && nodenamelen) {
262 enodename = malloc(nodenamelen);
263 if(!enodename)
264 return EAI_MEMORY;
265 }
267 if(servname && servnamelen) {
268 eservname = malloc(servnamelen);
269 if(!eservname) {
270 free(enodename);
271 return EAI_MEMORY;
272 }
273 }
275 status = getnameinfo(sa, salen, enodename, nodenamelen, eservname,
276 servnamelen, flags);
278 if(!status) {
279 int i;
280 if(enodename) {
281 i = QadrtConvertE2A(nodename, enodename, nodenamelen - 1,
282 strlen(enodename));
283 nodename[i] = '\0';
284 }
286 if(eservname) {
287 i = QadrtConvertE2A(servname, eservname, servnamelen - 1,
288 strlen(eservname));
289 servname[i] = '\0';
290 }
291 }
293 free(enodename);
294 free(eservname);
295 return status;
298int Curl_getaddrinfo_a(const char *nodename, const char *servname,
299 const struct addrinfo *hints, struct addrinfo **res)
301 char *enodename;
302 char *eservname;
303 int status;
304 int i;
306 enodename = (char *)NULL;
307 eservname = (char *)NULL;
309 if(nodename) {
310 i = strlen(nodename);
312 enodename = malloc(i + 1);
313 if(!enodename)
314 return EAI_MEMORY;
316 i = QadrtConvertA2E(enodename, nodename, i, i);
317 enodename[i] = '\0';
318 }
320 if(servname) {
321 i = strlen(servname);
323 eservname = malloc(i + 1);
324 if(!eservname) {
325 free(enodename);
326 return EAI_MEMORY;
327 }
329 QadrtConvertA2E(eservname, servname, i, i);
330 eservname[i] = '\0';
331 }
333 /* !checksrc! disable BANNEDFUNC 1 */
334 status = getaddrinfo(enodename, eservname, hints, res);
335 free(enodename);
336 free(eservname);
337 return status;
340#ifdef HAVE_GSSAPI
342/* ASCII wrappers for the GSSAPI procedures. */
344static int Curl_gss_convert_in_place(OM_uint32 *minor_status, gss_buffer_t buf)
346 unsigned int i = buf->length;
348 /* Convert `buf' in place, from EBCDIC to ASCII.
349 If error, release the buffer and return -1. Else return 0. */
351 if(i) {
352 char *t = malloc(i);
353 if(!t) {
354 gss_release_buffer(minor_status, buf);
356 if(minor_status)
357 /* !checksrc! disable ERRNOVAR 1 */
358 *minor_status = ENOMEM;
360 return -1;
361 }
363 QadrtConvertE2A(t, buf->value, i, i);
364 memcpy(buf->value, t, i);
365 free(t);
366 }
368 return 0;
371/* Max string input length is a precaution against abuse and to detect junk
372 input easier and better. */
373#define CURL_MAX_INPUT_LENGTH 8000000
375OM_uint32 Curl_gss_import_name_a(OM_uint32 *minor_status, gss_buffer_t in_name,
376 gss_OID in_name_type, gss_name_t *out_name)
378 OM_uint32 rc;
379 unsigned int i;
380 gss_buffer_desc in;
382 if(!in_name || !in_name->value || !in_name->length)
383 return gss_import_name(minor_status, in_name, in_name_type, out_name);
385 memcpy((char *)&in, (char *)in_name, sizeof(in));
386 if(in.length > CURL_MAX_INPUT_LENGTH) {
387 if(minor_status)
388 /* !checksrc! disable ERRNOVAR 1 */
389 *minor_status = ENOMEM;
391 return GSS_S_FAILURE;
392 }
393 i = (unsigned int)in.length;
395 in.value = malloc(i + 1);
396 if(!in.value) {
397 if(minor_status)
398 /* !checksrc! disable ERRNOVAR 1 */
399 *minor_status = ENOMEM;
401 return GSS_S_FAILURE;
402 }
404 QadrtConvertA2E(in.value, in_name->value, i, i);
405 ((char *)in.value)[i] = '\0';
406 rc = gss_import_name(minor_status, &in, in_name_type, out_name);
407 free(in.value);
408 return rc;
411OM_uint32 Curl_gss_display_status_a(OM_uint32 *minor_status,
412 OM_uint32 status_value, int status_type,
413 gss_OID mech_type,
414 gss_msg_ctx_t *message_context,
415 gss_buffer_t status_string)
417 int rc;
419 rc = gss_display_status(minor_status, status_value, status_type,
420 mech_type, message_context, status_string);
422 if(rc != GSS_S_COMPLETE || !status_string ||
423 !status_string->length || !status_string->value)
424 return rc;
426 /* No way to allocate a buffer here, because it will be released by
427 gss_release_buffer(). The solution is to overwrite the EBCDIC buffer
428 with ASCII to return it. */
430 if(Curl_gss_convert_in_place(minor_status, status_string))
431 return GSS_S_FAILURE;
433 return rc;
436OM_uint32 Curl_gss_init_sec_context_a(
437 OM_uint32 *minor_status,
438 gss_cred_id_t cred_handle,
439 gss_ctx_id_t *context_handle,
440 gss_name_t target_name, gss_OID mech_type,
441 gss_flags_t req_flags, OM_uint32 time_req,
442 gss_channel_bindings_t input_chan_bindings,
443 gss_buffer_t input_token,
444 gss_OID *actual_mech_type,
445 gss_buffer_t output_token, gss_flags_t *ret_flags,
446 OM_uint32 *time_rec)
448 int rc;
449 gss_buffer_desc in;
450 gss_buffer_t inp;
452 in.value = NULL;
453 inp = input_token;
455 if(inp) {
456 if(inp->length && inp->value) {
457 unsigned int i;
458 if(inp->length > CURL_MAX_INPUT_LENGTH) {
459 if(minor_status)
460 /* !checksrc! disable ERRNOVAR 1 */
461 *minor_status = ENOMEM;
463 return GSS_S_FAILURE;
464 }
465 i = (unsigned int)inp->length;
466 in.value = malloc(i + 1);
467 if(!in.value) {
468 if(minor_status)
469 /* !checksrc! disable ERRNOVAR 1 */
470 *minor_status = ENOMEM;
472 return GSS_S_FAILURE;
473 }
475 QadrtConvertA2E(in.value, input_token->value, i, i);
476 ((char *)in.value)[i] = '\0';
477 in.length = i;
478 inp = &in;
479 }
480 }
482 rc = gss_init_sec_context(minor_status, cred_handle, context_handle,
483 target_name, mech_type, req_flags, time_req,
484 input_chan_bindings, inp, actual_mech_type,
485 output_token, ret_flags, time_rec);
486 free(in.value);
488 if(rc != GSS_S_COMPLETE || !output_token ||
489 !output_token->length || !output_token->value)
490 return rc;
492 /* No way to allocate a buffer here, because it will be released by
493 gss_release_buffer(). The solution is to overwrite the EBCDIC buffer
494 with ASCII to return it. */
496 if(Curl_gss_convert_in_place(minor_status, output_token))
497 return GSS_S_FAILURE;
499 return rc;
502OM_uint32 Curl_gss_delete_sec_context_a(OM_uint32 *minor_status,
503 gss_ctx_id_t *context_handle,
504 gss_buffer_t output_token)
506 OM_uint32 rc;
508 rc = gss_delete_sec_context(minor_status, context_handle, output_token);
510 if(rc != GSS_S_COMPLETE || !output_token ||
511 !output_token->length || !output_token->value)
512 return rc;
514 /* No way to allocate a buffer here, because it will be released by
515 gss_release_buffer(). The solution is to overwrite the EBCDIC buffer
516 with ASCII to return it. */
518 if(Curl_gss_convert_in_place(minor_status, output_token))
519 return GSS_S_FAILURE;
521 return rc;
524#endif /* HAVE_GSSAPI */
526#ifndef CURL_DISABLE_LDAP
528/* ASCII wrappers for the LDAP procedures. */
530void *Curl_ldap_init_a(char *host, int port)
532 size_t i;
533 char *ehost;
534 void *result;
536 if(!host)
537 return (void *)ldap_init(host, port);
539 i = strlen(host);
541 ehost = malloc(i + 1);
542 if(!ehost)
543 return (void *)NULL;
545 QadrtConvertA2E(ehost, host, i, i);
546 ehost[i] = '\0';
547 result = (void *)ldap_init(ehost, port);
548 free(ehost);
549 return result;
552int Curl_ldap_simple_bind_s_a(void *ld, char *dn, char *passwd)
554 int i;
555 char *edn;
556 char *epasswd;
558 edn = (char *)NULL;
559 epasswd = (char *)NULL;
561 if(dn) {
562 i = strlen(dn);
564 edn = malloc(i + 1);
565 if(!edn)
566 return LDAP_NO_MEMORY;
568 QadrtConvertA2E(edn, dn, i, i);
569 edn[i] = '\0';
570 }
572 if(passwd) {
573 i = strlen(passwd);
575 epasswd = malloc(i + 1);
576 if(!epasswd) {
577 free(edn);
578 return LDAP_NO_MEMORY;
579 }
581 QadrtConvertA2E(epasswd, passwd, i, i);
582 epasswd[i] = '\0';
583 }
585 i = ldap_simple_bind_s(ld, edn, epasswd);
586 free(epasswd);
587 free(edn);
588 return i;
591int Curl_ldap_search_s_a(void *ld, char *base, int scope, char *filter,
592 char **attrs, int attrsonly, LDAPMessage **res)
594 int i;
595 int j;
596 char *ebase;
597 char *efilter;
598 char **eattrs;
599 int status;
601 ebase = (char *)NULL;
602 efilter = (char *)NULL;
603 eattrs = (char **)NULL;
604 status = LDAP_SUCCESS;
606 if(base) {
607 i = strlen(base);
609 ebase = malloc(i + 1);
610 if(!ebase)
611 status = LDAP_NO_MEMORY;
612 else {
613 QadrtConvertA2E(ebase, base, i, i);
614 ebase[i] = '\0';
615 }
616 }
618 if(filter && status == LDAP_SUCCESS) {
619 i = strlen(filter);
621 efilter = malloc(i + 1);
622 if(!efilter)
623 status = LDAP_NO_MEMORY;
624 else {
625 QadrtConvertA2E(efilter, filter, i, i);
626 efilter[i] = '\0';
627 }
628 }
630 if(attrs && status == LDAP_SUCCESS) {
631 for(i = 0; attrs[i++];)
632 ;
634 eattrs = calloc(i, sizeof(*eattrs));
635 if(!eattrs)
636 status = LDAP_NO_MEMORY;
637 else {
638 for(j = 0; attrs[j]; j++) {
639 i = strlen(attrs[j]);
641 eattrs[j] = malloc(i + 1);
642 if(!eattrs[j]) {
643 status = LDAP_NO_MEMORY;
644 break;
645 }
647 QadrtConvertA2E(eattrs[j], attrs[j], i, i);
648 eattrs[j][i] = '\0';
649 }
650 }
651 }
653 if(status == LDAP_SUCCESS)
654 status = ldap_search_s(ld, ebase ? ebase : "", scope,
655 efilter ? efilter : "(objectclass=*)",
656 eattrs, attrsonly, res);
658 if(eattrs) {
659 for(j = 0; eattrs[j]; j++)
660 free(eattrs[j]);
662 free(eattrs);
663 }
665 free(efilter);
666 free(ebase);
667 return status;
670struct berval **Curl_ldap_get_values_len_a(void *ld, LDAPMessage *entry,
671 const char *attr)
673 char *cp;
674 struct berval **result;
676 cp = (char *)NULL;
678 if(attr) {
679 int i = strlen(attr);
681 cp = malloc(i + 1);
682 if(!cp) {
683 ldap_set_lderrno(ld, LDAP_NO_MEMORY, NULL,
684 ldap_err2string(LDAP_NO_MEMORY));
685 return (struct berval **)NULL;
686 }
688 QadrtConvertA2E(cp, attr, i, i);
689 cp[i] = '\0';
690 }
692 result = ldap_get_values_len(ld, entry, cp);
693 free(cp);
695 /* Result data are binary in nature, so they have not been
696 converted to EBCDIC. Therefore do not convert. */
698 return result;
701char *Curl_ldap_err2string_a(int error)
703 return set_thread_string(LK_LDAP_ERROR, ldap_err2string(error));
706char *Curl_ldap_get_dn_a(void *ld, LDAPMessage *entry)
708 int i;
709 char *cp;
710 char *cp2;
712 cp = ldap_get_dn(ld, entry);
714 if(!cp)
715 return cp;
717 i = strlen(cp);
719 cp2 = malloc(i + 1);
720 if(!cp2)
721 return cp2;
723 QadrtConvertE2A(cp2, cp, i, i);
725 /* No way to allocate a buffer here, because it will be released by
726 ldap_memfree() and ldap_memalloc() does not exist. The solution is to
727 overwrite the EBCDIC buffer with ASCII to return it.
729 The destination buffer already has a null-terminator at the correct
730 position. Keep it outouched and copy the buffer without a terminator. */
731 memcpy(cp, cp2, i);
732 free(cp2);
733 return cp;
736char *Curl_ldap_first_attribute_a(void *ld, LDAPMessage *entry,
737 BerElement **berptr)
739 int i;
740 char *cp;
741 char *cp2;
743 cp = ldap_first_attribute(ld, entry, berptr);
745 if(!cp)
746 return cp;
748 i = strlen(cp);
750 cp2 = malloc(i + 1);
751 if(!cp2)
752 return cp2;
754 QadrtConvertE2A(cp2, cp, i, i);
756 /* No way to allocate a buffer here, because it will be released by
757 ldap_memfree() and ldap_memalloc() does not exist. The solution is to
758 overwrite the EBCDIC buffer with ASCII to return it.
760 The destination buffer already has a null-terminator at the correct
761 position. Keep it outouched and copy the buffer without a terminator. */
762 memcpy(cp, cp2, i);
763 free(cp2);
764 return cp;
767char *Curl_ldap_next_attribute_a(void *ld, LDAPMessage *entry,
768 BerElement *berptr)
770 int i;
771 char *cp;
772 char *cp2;
774 cp = ldap_next_attribute(ld, entry, berptr);
776 if(!cp)
777 return cp;
779 i = strlen(cp);
781 cp2 = malloc(i + 1);
782 if(!cp2)
783 return cp2;
785 QadrtConvertE2A(cp2, cp, i, i);
787 /* No way to allocate a buffer here, because it will be released by
788 ldap_memfree() and ldap_memalloc() does not exist. The solution is to
789 overwrite the EBCDIC buffer with ASCII to return it.
791 The destination buffer already has a null-terminator at the correct
792 position. Keep it outouched and copy the buffer without a terminator. */
793 memcpy(cp, cp2, i);
794 free(cp2);
795 return cp;
798#endif /* CURL_DISABLE_LDAP */
800static int sockaddr2ebcdic(struct sockaddr_storage *dstaddr,
801 const struct sockaddr *srcaddr, int srclen)
803 const struct sockaddr_un *srcu;
804 struct sockaddr_un *dstu;
805 unsigned int i;
806 unsigned int dstsize;
808 /* Convert a socket address to job CCSID, if needed. */
810 if(!srcaddr || srclen < offsetof(struct sockaddr, sa_family) +
811 sizeof(srcaddr->sa_family) || srclen > sizeof(*dstaddr)) {
812 /* !checksrc! disable ERRNOVAR 1 */
813 errno = EINVAL;
814 return -1;
815 }
817 memcpy((char *)dstaddr, (char *)srcaddr, srclen);
819 switch(srcaddr->sa_family) {
821 case AF_UNIX:
822 srcu = (const struct sockaddr_un *)srcaddr;
823 dstu = (struct sockaddr_un *)dstaddr;
824 dstsize = sizeof(*dstaddr) - offsetof(struct sockaddr_un, sun_path);
825 srclen -= offsetof(struct sockaddr_un, sun_path);
826 i = QadrtConvertA2E(dstu->sun_path, srcu->sun_path, dstsize - 1, srclen);
827 dstu->sun_path[i] = '\0';
828 srclen = i + offsetof(struct sockaddr_un, sun_path);
829 }
831 return srclen;
834static int sockaddr2ascii(struct sockaddr *dstaddr, int dstlen,
835 const struct sockaddr_storage *srcaddr, int srclen)
837 const struct sockaddr_un *srcu;
838 struct sockaddr_un *dstu;
839 unsigned int dstsize;
841 /* Convert a socket address to ASCII, if needed. */
843 if(!srclen)
844 return 0;
845 if(srclen > dstlen)
846 srclen = dstlen;
847 if(!srcaddr || srclen < 0) {
848 /* !checksrc! disable ERRNOVAR 1 */
849 errno = EINVAL;
850 return -1;
851 }
853 memcpy((char *)dstaddr, (char *)srcaddr, srclen);
855 if(srclen >= offsetof(struct sockaddr_storage, ss_family) +
856 sizeof(srcaddr->ss_family)) {
857 switch(srcaddr->ss_family) {
859 case AF_UNIX:
860 srcu = (const struct sockaddr_un *)srcaddr;
861 dstu = (struct sockaddr_un *)dstaddr;
862 dstsize = dstlen - offsetof(struct sockaddr_un, sun_path);
863 srclen -= offsetof(struct sockaddr_un, sun_path);
864 if(dstsize > 0 && srclen > 0) {
865 srclen = QadrtConvertE2A(dstu->sun_path, srcu->sun_path,
866 dstsize - 1, srclen);
867 dstu->sun_path[srclen] = '\0';
868 }
869 srclen += offsetof(struct sockaddr_un, sun_path);
870 }
871 }
873 return srclen;
876int Curl_os400_connect(int sd, struct sockaddr *destaddr, int addrlen)
878 int i;
879 struct sockaddr_storage laddr;
881 i = sockaddr2ebcdic(&laddr, destaddr, addrlen);
883 if(i < 0)
884 return -1;
886 return connect(sd, (struct sockaddr *)&laddr, i);
889int Curl_os400_bind(int sd, struct sockaddr *localaddr, int addrlen)
891 int i;
892 struct sockaddr_storage laddr;
894 i = sockaddr2ebcdic(&laddr, localaddr, addrlen);
896 if(i < 0)
897 return -1;
899 return bind(sd, (struct sockaddr *)&laddr, i);
902int Curl_os400_sendto(int sd, char *buffer, int buflen, int flags,
903 const struct sockaddr *dstaddr, int addrlen)
905 int i;
906 struct sockaddr_storage laddr;
908 i = sockaddr2ebcdic(&laddr, dstaddr, addrlen);
910 if(i < 0)
911 return -1;
913 return sendto(sd, buffer, buflen, flags, (struct sockaddr *)&laddr, i);
916int Curl_os400_recvfrom(int sd, char *buffer, int buflen, int flags,
917 struct sockaddr *fromaddr, int *addrlen)
919 int rcvlen;
920 struct sockaddr_storage laddr;
921 int laddrlen = sizeof(laddr);
923 if(!fromaddr || !addrlen || *addrlen <= 0)
924 return recvfrom(sd, buffer, buflen, flags, fromaddr, addrlen);
926 laddr.ss_family = AF_UNSPEC; /* To detect if unused. */
927 rcvlen = recvfrom(sd, buffer, buflen, flags,
928 (struct sockaddr *)&laddr, &laddrlen);
930 if(rcvlen < 0)
931 return rcvlen;
933 if(laddr.ss_family == AF_UNSPEC)
934 laddrlen = 0;
935 else {
936 laddrlen = sockaddr2ascii(fromaddr, *addrlen, &laddr, laddrlen);
937 if(laddrlen < 0)
938 return laddrlen;
939 }
940 *addrlen = laddrlen;
941 return rcvlen;
944int Curl_os400_getpeername(int sd, struct sockaddr *addr, int *addrlen)
946 struct sockaddr_storage laddr;
947 int laddrlen = sizeof(laddr);
948 int retcode = getpeername(sd, (struct sockaddr *)&laddr, &laddrlen);
950 if(!retcode) {
951 laddrlen = sockaddr2ascii(addr, *addrlen, &laddr, laddrlen);
952 if(laddrlen < 0)
953 return laddrlen;
954 *addrlen = laddrlen;
955 }
957 return retcode;
960int Curl_os400_getsockname(int sd, struct sockaddr *addr, int *addrlen)
962 struct sockaddr_storage laddr;
963 int laddrlen = sizeof(laddr);
964 int retcode = getsockname(sd, (struct sockaddr *)&laddr, &laddrlen);
966 if(!retcode) {
967 laddrlen = sockaddr2ascii(addr, *addrlen, &laddr, laddrlen);
968 if(laddrlen < 0)
969 return laddrlen;
970 *addrlen = laddrlen;
971 }
973 return retcode;
976#ifdef HAVE_LIBZ
977const char *Curl_os400_zlibVersion(void)
979 return set_thread_string(LK_ZLIB_VERSION, zlibVersion());
982int Curl_os400_inflateInit_(z_streamp strm, const char *version,
983 int stream_size)
985 z_const char *msgb4 = strm->msg;
986 int ret;
988 ret = inflateInit(strm);
990 if(strm->msg != msgb4)
991 strm->msg = set_thread_string(LK_ZLIB_MSG, strm->msg);
993 return ret;
996int Curl_os400_inflateInit2_(z_streamp strm, int windowBits,
997 const char *version, int stream_size)
999 z_const char *msgb4 = strm->msg;
1000 int ret;
1002 ret = inflateInit2(strm, windowBits);
1004 if(strm->msg != msgb4)
1005 strm->msg = set_thread_string(LK_ZLIB_MSG, strm->msg);
1007 return ret;
1010int Curl_os400_inflate(z_streamp strm, int flush)
1012 z_const char *msgb4 = strm->msg;
1013 int ret;
1015 ret = inflate(strm, flush);
1017 if(strm->msg != msgb4)
1018 strm->msg = set_thread_string(LK_ZLIB_MSG, strm->msg);
1020 return ret;
1023int Curl_os400_inflateEnd(z_streamp strm)
1025 z_const char *msgb4 = strm->msg;
1026 int ret;
1028 ret = inflateEnd(strm);
1030 if(strm->msg != msgb4)
1031 strm->msg = set_thread_string(LK_ZLIB_MSG, strm->msg);
1033 return ret;
1036#endif /* HAVE_LIBZ */
Diagnostics4 git calls · 31 ms
CallStatusSizeTime031 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=26
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
fetch2006.4 KiB · hit26 ms
git.upload-pack fetch
http.response.status_code=200
git.response.bytes=6603
git.response.cache=HIT
git.response.duration_ms=26
git.fetch.wants=af97616d5cfbe69de562844d63b31a89ad29c019
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=6603
git.pkt.payload.max=6582
git.sideband.band1.bytes=6581
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
a5e193423c12ddf0
Request
85558cf2…
Protocol
v2 · sha1
Agent
gitty/1.0
Filter
advertised
Fetch
shallow filter sideband-all
Capabilities
agent ls-refs fetch object-format