Artifactspublic-v0

curl

master
ply4 git calls210 ms288 KiB2 cachedprotocol v2
101 lines2.6 KiBRaw

NAME

CURLOPT_UPLOAD - data upload

SYNOPSIS

c
#include <curl/curl.h>

CURLcode curl_easy_setopt(CURL *handle, CURLOPT_UPLOAD, long upload);

DESCRIPTION

The long parameter upload set to 1 tells the library to prepare for and perform an upload. The CURLOPT_READDATA(3) and CURLOPT_INFILESIZE(3) or CURLOPT_INFILESIZE_LARGE(3) options are also interesting for uploads. If the protocol is HTTP, uploading means using the PUT request unless you tell libcurl otherwise.

Using PUT with HTTP 1.1 implies the use of a "Expect: 100-continue" header. You can disable this header with CURLOPT_HTTPHEADER(3) as usual.

If you use PUT to an HTTP 1.1 server, you can upload data without knowing the size before starting the transfer. The library enables this by adding a header "Transfer-Encoding: chunked". With HTTP 1.0 or if you prefer not to use chunked transfer, you must specify the size of the data with CURLOPT_INFILESIZE(3) or CURLOPT_INFILESIZE_LARGE(3).

DEFAULT

0

%PROTOCOLS%

EXAMPLE

c
static size_t read_cb(char *ptr, size_t size, size_t nmemb, void *userdata)
{
  FILE *src = userdata;
  /* copy as much data as possible into the 'ptr' buffer, but no more than
     'size' * 'nmemb' bytes */
  size_t retcode = fread(ptr, size, nmemb, src);

  return retcode;
}

int main(void)
{
  CURL *curl = curl_easy_init();
  if(curl) {
    CURLcode result;
    FILE *src = fopen("local-file", "r");
    curl_off_t fsize = 1234; /* set this to the size of the input file */

    /* we want to use our own read function */
    curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_cb);

    /* enable uploading */
    curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);

    /* specify target */
    curl_easy_setopt(curl, CURLOPT_URL, "ftp://example.com/dir/to/newfile");

    /* now specify which pointer to pass to our callback */
    curl_easy_setopt(curl, CURLOPT_READDATA, src);

    /* Set the size of the file to upload */
    curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)fsize);

    /* Now run off and do what you have been told */
    result = curl_easy_perform(curl);
    curl_easy_cleanup(curl);
  }
}

%AVAILABILITY%

RETURN VALUE

curl_easy_setopt(3) returns a CURLcode indicating success or error.

CURLE_OK (0) means everything was OK, non-zero means an error occurred, see libcurl-errors(3).

1---
2c: Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
3SPDX-License-Identifier: curl
4Title: CURLOPT_UPLOAD
5Section: 3
6Source: libcurl
7See-also:
8 - CURLOPT_INFILESIZE_LARGE (3)
9 - CURLOPT_PUT (3)
10 - CURLOPT_READFUNCTION (3)
11Protocol:
12 - All
13Added-in: 7.1
14---
16# NAME
18CURLOPT_UPLOAD - data upload
20# SYNOPSIS
22~~~c
23#include <curl/curl.h>
25CURLcode curl_easy_setopt(CURL *handle, CURLOPT_UPLOAD, long upload);
26~~~
28# DESCRIPTION
30The long parameter *upload* set to 1 tells the library to prepare for and
31perform an upload. The CURLOPT_READDATA(3) and CURLOPT_INFILESIZE(3) or
32CURLOPT_INFILESIZE_LARGE(3) options are also interesting for uploads. If the
33protocol is HTTP, uploading means using the PUT request unless you tell
34libcurl otherwise.
36Using PUT with HTTP 1.1 implies the use of a "Expect: 100-continue" header.
37You can disable this header with CURLOPT_HTTPHEADER(3) as usual.
39If you use PUT to an HTTP 1.1 server, you can upload data without knowing the
40size before starting the transfer. The library enables this by adding a header
41"Transfer-Encoding: chunked". With HTTP 1.0 or if you prefer not to use
42chunked transfer, you must specify the size of the data with
43CURLOPT_INFILESIZE(3) or CURLOPT_INFILESIZE_LARGE(3).
45# DEFAULT
49# %PROTOCOLS%
51# EXAMPLE
53~~~c
54static size_t read_cb(char *ptr, size_t size, size_t nmemb, void *userdata)
56 FILE *src = userdata;
57 /* copy as much data as possible into the 'ptr' buffer, but no more than
58 'size' * 'nmemb' bytes */
59 size_t retcode = fread(ptr, size, nmemb, src);
61 return retcode;
64int main(void)
66 CURL *curl = curl_easy_init();
67 if(curl) {
68 CURLcode result;
69 FILE *src = fopen("local-file", "r");
70 curl_off_t fsize = 1234; /* set this to the size of the input file */
72 /* we want to use our own read function */
73 curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_cb);
75 /* enable uploading */
76 curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
78 /* specify target */
79 curl_easy_setopt(curl, CURLOPT_URL, "ftp://example.com/dir/to/newfile");
81 /* now specify which pointer to pass to our callback */
82 curl_easy_setopt(curl, CURLOPT_READDATA, src);
84 /* Set the size of the file to upload */
85 curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)fsize);
87 /* Now run off and do what you have been told */
88 result = curl_easy_perform(curl);
89 curl_easy_cleanup(curl);
90 }
92~~~
94# %AVAILABILITY%
96# RETURN VALUE
98curl_easy_setopt(3) returns a CURLcode indicating success or error.
100CURLE_OK (0) means everything was OK, non-zero means an error occurred, see
101libcurl-errors(3).
Diagnostics4 git calls · 210 ms
CallStatusSizeTime0210 ms
discover200152 B2 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
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 · hit2 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=2
git.response.bytes=149
git.response.cache=HIT
git.response.duration_ms=2
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=2
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
fetch2001.3 KiB206 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=206
git.response.bytes=1356
git.response.cache=MISS
git.response.duration_ms=206
git.fetch.wants=5c81b86fe472379d111d61105eb7738cfa10e688
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=1356
git.pkt.payload.max=1335
git.sideband.band1.bytes=1334
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
a5e356bdc8c12c38
Request
556b1a7e…
Protocol
v2 · sha1
Agent
gitty/1.0
Filter
advertised
Fetch
shallow filter sideband-all
Capabilities
agent ls-refs fetch object-format