677 lines
21 KiB
C
677 lines
21 KiB
C
|
/***************************************************************************
|
||
|
|
* _ _ ____ _
|
||
|
|
* Project ___| | | | _ \| |
|
||
|
|
* / __| | | | |_) | |
|
||
|
|
* | (__| |_| | _ <| |___
|
||
|
|
* \___|\___/|_| \_\_____|
|
||
|
|
*
|
||
|
|
* Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
|
||
|
|
*
|
||
|
|
* This software is licensed as described in the file COPYING, which
|
||
|
|
* you should have received as part of this distribution. The terms
|
||
|
|
* are also available at https://curl.se/docs/copyright.html.
|
||
|
|
*
|
||
|
|
* You may opt to use, copy, modify, merge, publish, distribute and/or sell
|
||
|
|
* copies of the Software, and permit persons to whom the Software is
|
||
|
|
* furnished to do so, under the terms of the COPYING file.
|
||
|
|
*
|
||
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
||
|
|
* KIND, either express or implied.
|
||
|
|
*
|
||
|
|
* SPDX-License-Identifier: curl
|
||
|
|
*
|
||
|
|
***************************************************************************/
|
||
|
|
#include "tool_setup.h"
|
||
|
|
#define ENABLE_CURLX_PRINTF
|
||
|
|
/* use our own printf() functions */
|
||
|
|
#include "curlx.h"
|
||
|
|
#include "tool_cfgable.h"
|
||
|
|
#include "tool_writeout.h"
|
||
|
|
#include "tool_writeout_json.h"
|
||
|
|
#include "dynbuf.h"
|
||
|
|
|
||
|
|
#include "memdebug.h" /* keep this as LAST include */
|
||
|
|
|
||
|
|
static int writeTime(FILE *stream, const struct writeoutvar *wovar,
|
||
|
|
struct per_transfer *per, CURLcode per_result,
|
||
|
|
bool use_json);
|
||
|
|
|
||
|
|
static int writeString(FILE *stream, const struct writeoutvar *wovar,
|
||
|
|
struct per_transfer *per, CURLcode per_result,
|
||
|
|
bool use_json);
|
||
|
|
|
||
|
|
static int writeLong(FILE *stream, const struct writeoutvar *wovar,
|
||
|
|
struct per_transfer *per, CURLcode per_result,
|
||
|
|
bool use_json);
|
||
|
|
|
||
|
|
static int writeOffset(FILE *stream, const struct writeoutvar *wovar,
|
||
|
|
struct per_transfer *per, CURLcode per_result,
|
||
|
|
bool use_json);
|
||
|
|
|
||
|
|
struct httpmap {
|
||
|
|
const char *str;
|
||
|
|
int num;
|
||
|
|
};
|
||
|
|
|
||
|
|
static const struct httpmap http_version[] = {
|
||
|
|
{ "0", CURL_HTTP_VERSION_NONE},
|
||
|
|
{ "1", CURL_HTTP_VERSION_1_0},
|
||
|
|
{ "1.1", CURL_HTTP_VERSION_1_1},
|
||
|
|
{ "2", CURL_HTTP_VERSION_2},
|
||
|
|
{ "3", CURL_HTTP_VERSION_3},
|
||
|
|
{ NULL, 0} /* end of list */
|
||
|
|
};
|
||
|
|
|
||
|
|
/* The designated write function should be the same as the CURLINFO return type
|
||
|
|
with exceptions special cased in the respective function. For example,
|
||
|
|
http_version uses CURLINFO_HTTP_VERSION which returns the version as a long,
|
||
|
|
however it is output as a string and therefore is handled in writeString.
|
||
|
|
|
||
|
|
Yes: "http_version": "1.1"
|
||
|
|
No: "http_version": 1.1
|
||
|
|
|
||
|
|
Variable names should be in alphabetical order.
|
||
|
|
*/
|
||
|
|
static const struct writeoutvar variables[] = {
|
||
|
|
{"certs", VAR_CERT, CURLINFO_NONE, writeString},
|
||
|
|
{"content_type", VAR_CONTENT_TYPE, CURLINFO_CONTENT_TYPE, writeString},
|
||
|
|
{"conn_id", VAR_CONN_ID, CURLINFO_CONN_ID, writeOffset},
|
||
|
|
{"errormsg", VAR_ERRORMSG, CURLINFO_NONE, writeString},
|
||
|
|
{"exitcode", VAR_EXITCODE, CURLINFO_NONE, writeLong},
|
||
|
|
{"filename_effective", VAR_EFFECTIVE_FILENAME, CURLINFO_NONE, writeString},
|
||
|
|
{"ftp_entry_path", VAR_FTP_ENTRY_PATH, CURLINFO_FTP_ENTRY_PATH, writeString},
|
||
|
|
{"header_json", VAR_HEADER_JSON, CURLINFO_NONE, NULL},
|
||
|
|
{"http_code", VAR_HTTP_CODE, CURLINFO_RESPONSE_CODE, writeLong},
|
||
|
|
{"http_connect", VAR_HTTP_CODE_PROXY, CURLINFO_HTTP_CONNECTCODE, writeLong},
|
||
|
|
{"http_version", VAR_HTTP_VERSION, CURLINFO_HTTP_VERSION, writeString},
|
||
|
|
{"json", VAR_JSON, CURLINFO_NONE, NULL},
|
||
|
|
{"local_ip", VAR_LOCAL_IP, CURLINFO_LOCAL_IP, writeString},
|
||
|
|
{"local_port", VAR_LOCAL_PORT, CURLINFO_LOCAL_PORT, writeLong},
|
||
|
|
{"method", VAR_EFFECTIVE_METHOD, CURLINFO_EFFECTIVE_METHOD, writeString},
|
||
|
|
{"num_certs", VAR_NUM_CERTS, CURLINFO_NONE, writeLong},
|
||
|
|
{"num_connects", VAR_NUM_CONNECTS, CURLINFO_NUM_CONNECTS, writeLong},
|
||
|
|
{"num_headers", VAR_NUM_HEADERS, CURLINFO_NONE, writeLong},
|
||
|
|
{"num_redirects", VAR_REDIRECT_COUNT, CURLINFO_REDIRECT_COUNT, writeLong},
|
||
|
|
{"onerror", VAR_ONERROR, CURLINFO_NONE, NULL},
|
||
|
|
{"proxy_ssl_verify_result", VAR_PROXY_SSL_VERIFY_RESULT,
|
||
|
|
CURLINFO_PROXY_SSL_VERIFYRESULT, writeLong},
|
||
|
|
{"proxy_used", VAR_PROXY_USED, CURLINFO_USED_PROXY, writeLong},
|
||
|
|
{"redirect_url", VAR_REDIRECT_URL, CURLINFO_REDIRECT_URL, writeString},
|
||
|
|
{"referer", VAR_REFERER, CURLINFO_REFERER, writeString},
|
||
|
|
{"remote_ip", VAR_PRIMARY_IP, CURLINFO_PRIMARY_IP, writeString},
|
||
|
|
{"remote_port", VAR_PRIMARY_PORT, CURLINFO_PRIMARY_PORT, writeLong},
|
||
|
|
{"response_code", VAR_HTTP_CODE, CURLINFO_RESPONSE_CODE, writeLong},
|
||
|
|
{"scheme", VAR_SCHEME, CURLINFO_SCHEME, writeString},
|
||
|
|
{"size_download", VAR_SIZE_DOWNLOAD, CURLINFO_SIZE_DOWNLOAD_T, writeOffset},
|
||
|
|
{"size_header", VAR_HEADER_SIZE, CURLINFO_HEADER_SIZE, writeLong},
|
||
|
|
{"size_request", VAR_REQUEST_SIZE, CURLINFO_REQUEST_SIZE, writeLong},
|
||
|
|
{"size_upload", VAR_SIZE_UPLOAD, CURLINFO_SIZE_UPLOAD_T, writeOffset},
|
||
|
|
{"speed_download", VAR_SPEED_DOWNLOAD, CURLINFO_SPEED_DOWNLOAD_T,
|
||
|
|
writeOffset},
|
||
|
|
{"speed_upload", VAR_SPEED_UPLOAD, CURLINFO_SPEED_UPLOAD_T, writeOffset},
|
||
|
|
{"ssl_verify_result", VAR_SSL_VERIFY_RESULT, CURLINFO_SSL_VERIFYRESULT,
|
||
|
|
writeLong},
|
||
|
|
{"stderr", VAR_STDERR, CURLINFO_NONE, NULL},
|
||
|
|
{"stdout", VAR_STDOUT, CURLINFO_NONE, NULL},
|
||
|
|
{"time_appconnect", VAR_APPCONNECT_TIME, CURLINFO_APPCONNECT_TIME_T,
|
||
|
|
writeTime},
|
||
|
|
{"time_connect", VAR_CONNECT_TIME, CURLINFO_CONNECT_TIME_T, writeTime},
|
||
|
|
{"time_namelookup", VAR_NAMELOOKUP_TIME, CURLINFO_NAMELOOKUP_TIME_T,
|
||
|
|
writeTime},
|
||
|
|
{"time_pretransfer", VAR_PRETRANSFER_TIME, CURLINFO_PRETRANSFER_TIME_T,
|
||
|
|
writeTime},
|
||
|
|
{"time_redirect", VAR_REDIRECT_TIME, CURLINFO_REDIRECT_TIME_T, writeTime},
|
||
|
|
{"time_starttransfer", VAR_STARTTRANSFER_TIME, CURLINFO_STARTTRANSFER_TIME_T,
|
||
|
|
writeTime},
|
||
|
|
{"time_total", VAR_TOTAL_TIME, CURLINFO_TOTAL_TIME_T, writeTime},
|
||
|
|
{"url", VAR_INPUT_URL, CURLINFO_NONE, writeString},
|
||
|
|
{"url.scheme", VAR_INPUT_URLSCHEME, CURLINFO_NONE, writeString},
|
||
|
|
{"url.user", VAR_INPUT_URLUSER, CURLINFO_NONE, writeString},
|
||
|
|
{"url.password", VAR_INPUT_URLPASSWORD, CURLINFO_NONE, writeString},
|
||
|
|
{"url.options", VAR_INPUT_URLOPTIONS, CURLINFO_NONE, writeString},
|
||
|
|
{"url.host", VAR_INPUT_URLHOST, CURLINFO_NONE, writeString},
|
||
|
|
{"url.port", VAR_INPUT_URLPORT, CURLINFO_NONE, writeString},
|
||
|
|
{"url.path", VAR_INPUT_URLPATH, CURLINFO_NONE, writeString},
|
||
|
|
{"url.query", VAR_INPUT_URLQUERY, CURLINFO_NONE, writeString},
|
||
|
|
{"url.fragment", VAR_INPUT_URLFRAGMENT, CURLINFO_NONE, writeString},
|
||
|
|
{"url.zoneid", VAR_INPUT_URLZONEID, CURLINFO_NONE, writeString},
|
||
|
|
{"urle.scheme", VAR_INPUT_URLESCHEME, CURLINFO_NONE, writeString},
|
||
|
|
{"urle.user", VAR_INPUT_URLEUSER, CURLINFO_NONE, writeString},
|
||
|
|
{"urle.password", VAR_INPUT_URLEPASSWORD, CURLINFO_NONE, writeString},
|
||
|
|
{"urle.options", VAR_INPUT_URLEOPTIONS, CURLINFO_NONE, writeString},
|
||
|
|
{"urle.host", VAR_INPUT_URLEHOST, CURLINFO_NONE, writeString},
|
||
|
|
{"urle.port", VAR_INPUT_URLEPORT, CURLINFO_NONE, writeString},
|
||
|
|
{"urle.path", VAR_INPUT_URLEPATH, CURLINFO_NONE, writeString},
|
||
|
|
{"urle.query", VAR_INPUT_URLEQUERY, CURLINFO_NONE, writeString},
|
||
|
|
{"urle.fragment", VAR_INPUT_URLEFRAGMENT, CURLINFO_NONE, writeString},
|
||
|
|
{"urle.zoneid", VAR_INPUT_URLEZONEID, CURLINFO_NONE, writeString},
|
||
|
|
{"url_effective", VAR_EFFECTIVE_URL, CURLINFO_EFFECTIVE_URL, writeString},
|
||
|
|
{"urlnum", VAR_URLNUM, CURLINFO_NONE, writeLong},
|
||
|
|
{"xfer_id", VAR_EASY_ID, CURLINFO_XFER_ID, writeOffset},
|
||
|
|
{NULL, VAR_NONE, CURLINFO_NONE, NULL}
|
||
|
|
};
|
||
|
|
|
||
|
|
static int writeTime(FILE *stream, const struct writeoutvar *wovar,
|
||
|
|
struct per_transfer *per, CURLcode per_result,
|
||
|
|
bool use_json)
|
||
|
|
{
|
||
|
|
bool valid = false;
|
||
|
|
curl_off_t us = 0;
|
||
|
|
|
||
|
|
(void)per;
|
||
|
|
(void)per_result;
|
||
|
|
DEBUGASSERT(wovar->writefunc == writeTime);
|
||
|
|
|
||
|
|
if(wovar->ci) {
|
||
|
|
if(!curl_easy_getinfo(per->curl, wovar->ci, &us))
|
||
|
|
valid = true;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
DEBUGASSERT(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
if(valid) {
|
||
|
|
curl_off_t secs = us / 1000000;
|
||
|
|
us %= 1000000;
|
||
|
|
|
||
|
|
if(use_json)
|
||
|
|
fprintf(stream, "\"%s\":", wovar->name);
|
||
|
|
|
||
|
|
fprintf(stream, "%" CURL_FORMAT_CURL_OFF_TU
|
||
|
|
".%06" CURL_FORMAT_CURL_OFF_TU, secs, us);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
if(use_json)
|
||
|
|
fprintf(stream, "\"%s\":null", wovar->name);
|
||
|
|
}
|
||
|
|
|
||
|
|
return 1; /* return 1 if anything was written */
|
||
|
|
}
|
||
|
|
|
||
|
|
static int urlpart(struct per_transfer *per, writeoutid vid,
|
||
|
|
const char **contentp)
|
||
|
|
{
|
||
|
|
CURLU *uh = curl_url();
|
||
|
|
int rc = 0;
|
||
|
|
if(uh) {
|
||
|
|
CURLUPart cpart = CURLUPART_HOST;
|
||
|
|
char *part = NULL;
|
||
|
|
const char *url = NULL;
|
||
|
|
|
||
|
|
if(vid >= VAR_INPUT_URLEHOST) {
|
||
|
|
if(curl_easy_getinfo(per->curl, CURLINFO_EFFECTIVE_URL, &url))
|
||
|
|
rc = 5;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
url = per->this_url;
|
||
|
|
|
||
|
|
if(!rc) {
|
||
|
|
switch(vid) {
|
||
|
|
case VAR_INPUT_URLSCHEME:
|
||
|
|
case VAR_INPUT_URLESCHEME:
|
||
|
|
cpart = CURLUPART_SCHEME;
|
||
|
|
break;
|
||
|
|
case VAR_INPUT_URLUSER:
|
||
|
|
case VAR_INPUT_URLEUSER:
|
||
|
|
cpart = CURLUPART_USER;
|
||
|
|
break;
|
||
|
|
case VAR_INPUT_URLPASSWORD:
|
||
|
|
case VAR_INPUT_URLEPASSWORD:
|
||
|
|
cpart = CURLUPART_PASSWORD;
|
||
|
|
break;
|
||
|
|
case VAR_INPUT_URLOPTIONS:
|
||
|
|
case VAR_INPUT_URLEOPTIONS:
|
||
|
|
cpart = CURLUPART_OPTIONS;
|
||
|
|
break;
|
||
|
|
case VAR_INPUT_URLHOST:
|
||
|
|
case VAR_INPUT_URLEHOST:
|
||
|
|
cpart = CURLUPART_HOST;
|
||
|
|
break;
|
||
|
|
case VAR_INPUT_URLPORT:
|
||
|
|
case VAR_INPUT_URLEPORT:
|
||
|
|
cpart = CURLUPART_PORT;
|
||
|
|
break;
|
||
|
|
case VAR_INPUT_URLPATH:
|
||
|
|
case VAR_INPUT_URLEPATH:
|
||
|
|
cpart = CURLUPART_PATH;
|
||
|
|
break;
|
||
|
|
case VAR_INPUT_URLQUERY:
|
||
|
|
case VAR_INPUT_URLEQUERY:
|
||
|
|
cpart = CURLUPART_QUERY;
|
||
|
|
break;
|
||
|
|
case VAR_INPUT_URLFRAGMENT:
|
||
|
|
case VAR_INPUT_URLEFRAGMENT:
|
||
|
|
cpart = CURLUPART_FRAGMENT;
|
||
|
|
break;
|
||
|
|
case VAR_INPUT_URLZONEID:
|
||
|
|
case VAR_INPUT_URLEZONEID:
|
||
|
|
cpart = CURLUPART_ZONEID;
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
/* not implemented */
|
||
|
|
rc = 4;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(!rc && curl_url_set(uh, CURLUPART_URL, url,
|
||
|
|
CURLU_GUESS_SCHEME|CURLU_NON_SUPPORT_SCHEME))
|
||
|
|
rc = 2;
|
||
|
|
|
||
|
|
if(!rc && curl_url_get(uh, cpart, &part, CURLU_DEFAULT_PORT))
|
||
|
|
rc = 3;
|
||
|
|
|
||
|
|
if(!rc && part)
|
||
|
|
*contentp = part;
|
||
|
|
curl_url_cleanup(uh);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
return 1;
|
||
|
|
return rc;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int writeString(FILE *stream, const struct writeoutvar *wovar,
|
||
|
|
struct per_transfer *per, CURLcode per_result,
|
||
|
|
bool use_json)
|
||
|
|
{
|
||
|
|
bool valid = false;
|
||
|
|
const char *strinfo = NULL;
|
||
|
|
const char *freestr = NULL;
|
||
|
|
struct dynbuf buf;
|
||
|
|
curlx_dyn_init(&buf, 256*1024);
|
||
|
|
|
||
|
|
DEBUGASSERT(wovar->writefunc == writeString);
|
||
|
|
|
||
|
|
if(wovar->ci) {
|
||
|
|
if(wovar->ci == CURLINFO_HTTP_VERSION) {
|
||
|
|
long version = 0;
|
||
|
|
if(!curl_easy_getinfo(per->curl, CURLINFO_HTTP_VERSION, &version)) {
|
||
|
|
const struct httpmap *m = &http_version[0];
|
||
|
|
while(m->str) {
|
||
|
|
if(m->num == version) {
|
||
|
|
strinfo = m->str;
|
||
|
|
valid = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
m++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
if(!curl_easy_getinfo(per->curl, wovar->ci, &strinfo) && strinfo)
|
||
|
|
valid = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
switch(wovar->id) {
|
||
|
|
case VAR_CERT:
|
||
|
|
if(per->certinfo) {
|
||
|
|
int i;
|
||
|
|
bool error = FALSE;
|
||
|
|
for(i = 0; (i < per->certinfo->num_of_certs) && !error; i++) {
|
||
|
|
struct curl_slist *slist;
|
||
|
|
|
||
|
|
for(slist = per->certinfo->certinfo[i]; slist; slist = slist->next) {
|
||
|
|
size_t len;
|
||
|
|
if(curl_strnequal(slist->data, "cert:", 5)) {
|
||
|
|
if(curlx_dyn_add(&buf, &slist->data[5])) {
|
||
|
|
error = TRUE;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
if(curlx_dyn_add(&buf, slist->data)) {
|
||
|
|
error = TRUE;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
len = curlx_dyn_len(&buf);
|
||
|
|
if(len) {
|
||
|
|
char *ptr = curlx_dyn_ptr(&buf);
|
||
|
|
if(ptr[len -1] != '\n') {
|
||
|
|
/* add a newline to make things look better */
|
||
|
|
if(curlx_dyn_addn(&buf, "\n", 1)) {
|
||
|
|
error = TRUE;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(!error) {
|
||
|
|
strinfo = curlx_dyn_ptr(&buf);
|
||
|
|
if(!strinfo)
|
||
|
|
/* maybe not a TLS protocol */
|
||
|
|
strinfo = "";
|
||
|
|
valid = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
strinfo = ""; /* no cert info */
|
||
|
|
break;
|
||
|
|
case VAR_ERRORMSG:
|
||
|
|
if(per_result) {
|
||
|
|
strinfo = (per->errorbuffer && per->errorbuffer[0]) ?
|
||
|
|
per->errorbuffer : curl_easy_strerror(per_result);
|
||
|
|
valid = true;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case VAR_EFFECTIVE_FILENAME:
|
||
|
|
if(per->outs.filename) {
|
||
|
|
strinfo = per->outs.filename;
|
||
|
|
valid = true;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case VAR_INPUT_URL:
|
||
|
|
if(per->this_url) {
|
||
|
|
strinfo = per->this_url;
|
||
|
|
valid = true;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case VAR_INPUT_URLSCHEME:
|
||
|
|
case VAR_INPUT_URLUSER:
|
||
|
|
case VAR_INPUT_URLPASSWORD:
|
||
|
|
case VAR_INPUT_URLOPTIONS:
|
||
|
|
case VAR_INPUT_URLHOST:
|
||
|
|
case VAR_INPUT_URLPORT:
|
||
|
|
case VAR_INPUT_URLPATH:
|
||
|
|
case VAR_INPUT_URLQUERY:
|
||
|
|
case VAR_INPUT_URLFRAGMENT:
|
||
|
|
case VAR_INPUT_URLZONEID:
|
||
|
|
case VAR_INPUT_URLESCHEME:
|
||
|
|
case VAR_INPUT_URLEUSER:
|
||
|
|
case VAR_INPUT_URLEPASSWORD:
|
||
|
|
case VAR_INPUT_URLEOPTIONS:
|
||
|
|
case VAR_INPUT_URLEHOST:
|
||
|
|
case VAR_INPUT_URLEPORT:
|
||
|
|
case VAR_INPUT_URLEPATH:
|
||
|
|
case VAR_INPUT_URLEQUERY:
|
||
|
|
case VAR_INPUT_URLEFRAGMENT:
|
||
|
|
case VAR_INPUT_URLEZONEID:
|
||
|
|
if(per->this_url) {
|
||
|
|
if(!urlpart(per, wovar->id, &strinfo)) {
|
||
|
|
freestr = strinfo;
|
||
|
|
valid = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
DEBUGASSERT(0);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(valid) {
|
||
|
|
DEBUGASSERT(strinfo);
|
||
|
|
if(use_json) {
|
||
|
|
fprintf(stream, "\"%s\":", wovar->name);
|
||
|
|
jsonWriteString(stream, strinfo, FALSE);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
fputs(strinfo, stream);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
if(use_json)
|
||
|
|
fprintf(stream, "\"%s\":null", wovar->name);
|
||
|
|
}
|
||
|
|
curl_free((char *)freestr);
|
||
|
|
|
||
|
|
curlx_dyn_free(&buf);
|
||
|
|
return 1; /* return 1 if anything was written */
|
||
|
|
}
|
||
|
|
|
||
|
|
static int writeLong(FILE *stream, const struct writeoutvar *wovar,
|
||
|
|
struct per_transfer *per, CURLcode per_result,
|
||
|
|
bool use_json)
|
||
|
|
{
|
||
|
|
bool valid = false;
|
||
|
|
long longinfo = 0;
|
||
|
|
|
||
|
|
DEBUGASSERT(wovar->writefunc == writeLong);
|
||
|
|
|
||
|
|
if(wovar->ci) {
|
||
|
|
if(!curl_easy_getinfo(per->curl, wovar->ci, &longinfo))
|
||
|
|
valid = true;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
switch(wovar->id) {
|
||
|
|
case VAR_NUM_CERTS:
|
||
|
|
longinfo = per->certinfo ? per->certinfo->num_of_certs : 0;
|
||
|
|
valid = true;
|
||
|
|
break;
|
||
|
|
case VAR_NUM_HEADERS:
|
||
|
|
longinfo = per->num_headers;
|
||
|
|
valid = true;
|
||
|
|
break;
|
||
|
|
case VAR_EXITCODE:
|
||
|
|
longinfo = (long)per_result;
|
||
|
|
valid = true;
|
||
|
|
break;
|
||
|
|
case VAR_URLNUM:
|
||
|
|
if(per->urlnum <= INT_MAX) {
|
||
|
|
longinfo = (long)per->urlnum;
|
||
|
|
valid = true;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
DEBUGASSERT(0);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(valid) {
|
||
|
|
if(use_json)
|
||
|
|
fprintf(stream, "\"%s\":%ld", wovar->name, longinfo);
|
||
|
|
else {
|
||
|
|
if(wovar->id == VAR_HTTP_CODE || wovar->id == VAR_HTTP_CODE_PROXY)
|
||
|
|
fprintf(stream, "%03ld", longinfo);
|
||
|
|
else
|
||
|
|
fprintf(stream, "%ld", longinfo);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
if(use_json)
|
||
|
|
fprintf(stream, "\"%s\":null", wovar->name);
|
||
|
|
}
|
||
|
|
|
||
|
|
return 1; /* return 1 if anything was written */
|
||
|
|
}
|
||
|
|
|
||
|
|
static int writeOffset(FILE *stream, const struct writeoutvar *wovar,
|
||
|
|
struct per_transfer *per, CURLcode per_result,
|
||
|
|
bool use_json)
|
||
|
|
{
|
||
|
|
bool valid = false;
|
||
|
|
curl_off_t offinfo = 0;
|
||
|
|
|
||
|
|
(void)per;
|
||
|
|
(void)per_result;
|
||
|
|
DEBUGASSERT(wovar->writefunc == writeOffset);
|
||
|
|
|
||
|
|
if(wovar->ci) {
|
||
|
|
if(!curl_easy_getinfo(per->curl, wovar->ci, &offinfo))
|
||
|
|
valid = true;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
DEBUGASSERT(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
if(valid) {
|
||
|
|
if(use_json)
|
||
|
|
fprintf(stream, "\"%s\":", wovar->name);
|
||
|
|
|
||
|
|
fprintf(stream, "%" CURL_FORMAT_CURL_OFF_T, offinfo);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
if(use_json)
|
||
|
|
fprintf(stream, "\"%s\":null", wovar->name);
|
||
|
|
}
|
||
|
|
|
||
|
|
return 1; /* return 1 if anything was written */
|
||
|
|
}
|
||
|
|
|
||
|
|
void ourWriteOut(struct OperationConfig *config, struct per_transfer *per,
|
||
|
|
CURLcode per_result)
|
||
|
|
{
|
||
|
|
FILE *stream = stdout;
|
||
|
|
const char *writeinfo = config->writeout;
|
||
|
|
const char *ptr = writeinfo;
|
||
|
|
bool done = FALSE;
|
||
|
|
struct curl_certinfo *certinfo;
|
||
|
|
CURLcode res = curl_easy_getinfo(per->curl, CURLINFO_CERTINFO, &certinfo);
|
||
|
|
bool fclose_stream = FALSE;
|
||
|
|
|
||
|
|
if(!writeinfo)
|
||
|
|
return;
|
||
|
|
|
||
|
|
if(!res && certinfo)
|
||
|
|
per->certinfo = certinfo;
|
||
|
|
|
||
|
|
while(ptr && *ptr && !done) {
|
||
|
|
if('%' == *ptr && ptr[1]) {
|
||
|
|
if('%' == ptr[1]) {
|
||
|
|
/* an escaped %-letter */
|
||
|
|
fputc('%', stream);
|
||
|
|
ptr += 2;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
/* this is meant as a variable to output */
|
||
|
|
char *end;
|
||
|
|
size_t vlen;
|
||
|
|
if('{' == ptr[1]) {
|
||
|
|
int i;
|
||
|
|
bool match = FALSE;
|
||
|
|
end = strchr(ptr, '}');
|
||
|
|
ptr += 2; /* pass the % and the { */
|
||
|
|
if(!end) {
|
||
|
|
fputs("%{", stream);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
vlen = end - ptr;
|
||
|
|
for(i = 0; variables[i].name; i++) {
|
||
|
|
if((strlen(variables[i].name) == vlen) &&
|
||
|
|
curl_strnequal(ptr, variables[i].name, vlen)) {
|
||
|
|
match = TRUE;
|
||
|
|
switch(variables[i].id) {
|
||
|
|
case VAR_ONERROR:
|
||
|
|
if(per_result == CURLE_OK)
|
||
|
|
/* this isn't error so skip the rest */
|
||
|
|
done = TRUE;
|
||
|
|
break;
|
||
|
|
case VAR_STDOUT:
|
||
|
|
if(fclose_stream)
|
||
|
|
fclose(stream);
|
||
|
|
fclose_stream = FALSE;
|
||
|
|
stream = stdout;
|
||
|
|
break;
|
||
|
|
case VAR_STDERR:
|
||
|
|
if(fclose_stream)
|
||
|
|
fclose(stream);
|
||
|
|
fclose_stream = FALSE;
|
||
|
|
stream = tool_stderr;
|
||
|
|
break;
|
||
|
|
case VAR_JSON:
|
||
|
|
ourWriteOutJSON(stream, variables, per, per_result);
|
||
|
|
break;
|
||
|
|
case VAR_HEADER_JSON:
|
||
|
|
headerJSON(stream, per);
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
(void)variables[i].writefunc(stream, &variables[i],
|
||
|
|
per, per_result, false);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(!match) {
|
||
|
|
fprintf(tool_stderr,
|
||
|
|
"curl: unknown --write-out variable: '%.*s'\n",
|
||
|
|
(int)vlen, ptr);
|
||
|
|
}
|
||
|
|
ptr = end + 1; /* pass the end */
|
||
|
|
}
|
||
|
|
else if(!strncmp("header{", &ptr[1], 7)) {
|
||
|
|
ptr += 8;
|
||
|
|
end = strchr(ptr, '}');
|
||
|
|
if(end) {
|
||
|
|
char hname[256]; /* holds the longest header field name */
|
||
|
|
struct curl_header *header;
|
||
|
|
vlen = end - ptr;
|
||
|
|
if(vlen < sizeof(hname)) {
|
||
|
|
memcpy(hname, ptr, vlen);
|
||
|
|
hname[vlen] = 0;
|
||
|
|
if(CURLHE_OK == curl_easy_header(per->curl, hname, 0,
|
||
|
|
CURLH_HEADER, -1, &header))
|
||
|
|
fputs(header->value, stream);
|
||
|
|
}
|
||
|
|
ptr = end + 1;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
fputs("%header{", stream);
|
||
|
|
}
|
||
|
|
else if(!strncmp("output{", &ptr[1], 7)) {
|
||
|
|
bool append = FALSE;
|
||
|
|
ptr += 8;
|
||
|
|
if((ptr[0] == '>') && (ptr[1] == '>')) {
|
||
|
|
append = TRUE;
|
||
|
|
ptr += 2;
|
||
|
|
}
|
||
|
|
end = strchr(ptr, '}');
|
||
|
|
if(end) {
|
||
|
|
char fname[512]; /* holds the longest file name */
|
||
|
|
size_t flen = end - ptr;
|
||
|
|
if(flen < sizeof(fname)) {
|
||
|
|
FILE *stream2;
|
||
|
|
memcpy(fname, ptr, flen);
|
||
|
|
fname[flen] = 0;
|
||
|
|
stream2 = fopen(fname, append? FOPEN_APPENDTEXT :
|
||
|
|
FOPEN_WRITETEXT);
|
||
|
|
if(stream2) {
|
||
|
|
/* only change if the open worked */
|
||
|
|
if(fclose_stream)
|
||
|
|
fclose(stream);
|
||
|
|
stream = stream2;
|
||
|
|
fclose_stream = TRUE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ptr = end + 1;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
fputs("%output{", stream);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
/* illegal syntax, then just output the characters that are used */
|
||
|
|
fputc('%', stream);
|
||
|
|
fputc(ptr[1], stream);
|
||
|
|
ptr += 2;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if('\\' == *ptr && ptr[1]) {
|
||
|
|
switch(ptr[1]) {
|
||
|
|
case 'r':
|
||
|
|
fputc('\r', stream);
|
||
|
|
break;
|
||
|
|
case 'n':
|
||
|
|
fputc('\n', stream);
|
||
|
|
break;
|
||
|
|
case 't':
|
||
|
|
fputc('\t', stream);
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
/* unknown, just output this */
|
||
|
|
fputc(*ptr, stream);
|
||
|
|
fputc(ptr[1], stream);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
ptr += 2;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
fputc(*ptr, stream);
|
||
|
|
ptr++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(fclose_stream)
|
||
|
|
fclose(stream);
|
||
|
|
}
|