... as checksrc now finds and complains about these.
Closes #14921
/* check for bytes downloaded */
res = curl_easy_getinfo(curl_handle, CURLINFO_SIZE_DOWNLOAD_T, &val);
- if((CURLE_OK == res) && (val>0))
+ if((CURLE_OK == res) && (val > 0))
printf("Data downloaded: %lu bytes.\n", (unsigned long)val);
/* check for total download time */
res = curl_easy_getinfo(curl_handle, CURLINFO_TOTAL_TIME_T, &val);
- if((CURLE_OK == res) && (val>0))
+ if((CURLE_OK == res) && (val > 0))
printf("Total download time: %lu.%06lu sec.\n",
(unsigned long)(val / 1000000), (unsigned long)(val % 1000000));
/* check for average download speed */
res = curl_easy_getinfo(curl_handle, CURLINFO_SPEED_DOWNLOAD_T, &val);
- if((CURLE_OK == res) && (val>0))
+ if((CURLE_OK == res) && (val > 0))
printf("Average download speed: %lu kbyte/sec.\n",
(unsigned long)(val / 1024));
if(prtall) {
/* check for name resolution time */
res = curl_easy_getinfo(curl_handle, CURLINFO_NAMELOOKUP_TIME_T, &val);
- if((CURLE_OK == res) && (val>0))
+ if((CURLE_OK == res) && (val > 0))
printf("Name lookup time: %lu.%06lu sec.\n",
(unsigned long)(val / 1000000), (unsigned long)(val % 1000000));
/* check for connect time */
res = curl_easy_getinfo(curl_handle, CURLINFO_CONNECT_TIME_T, &val);
- if((CURLE_OK == res) && (val>0))
+ if((CURLE_OK == res) && (val > 0))
printf("Connect time: %lu.%06lu sec.\n",
(unsigned long)(val / 1000000), (unsigned long)(val % 1000000));
}
fprintf(stream, "%s, %10.10lu bytes (0x%8.8lx)\n",
text, (unsigned long)size, (unsigned long)size);
- for(i = 0; i<size; i += width) {
+ for(i = 0; i < size; i += width) {
fprintf(stream, "%4.4lx: ", (unsigned long)i);
break;
}
fprintf(stream, "%c",
- (ptr[i + c] >= 0x20) && (ptr[i + c]<0x80)?ptr[i + c]:'.');
+ (ptr[i + c] >= 0x20) && (ptr[i + c] < 0x80) ? ptr[i + c] : '.');
/* check again for 0D0A, to avoid an extra \n if it's at width */
if(nohex && (i + c + 2 < size) && ptr[i + c + 1] == 0x0D &&
ptr[i + c + 2] == 0x0A) {
}
res = curl_easy_getinfo(curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T,
&filesize);
- if((CURLE_OK == res) && (filesize>0))
+ if((CURLE_OK == res) && (filesize > 0))
printf("filesize %s: %" CURL_FORMAT_CURL_OFF_T " bytes\n",
filename, filesize);
}
curl_easy_setopt(conn->easy, CURLOPT_VERBOSE, (long)SHOW_VERBOSE);
curl_easy_setopt(conn->easy, CURLOPT_ERRORBUFFER, conn->error);
curl_easy_setopt(conn->easy, CURLOPT_PRIVATE, conn);
- curl_easy_setopt(conn->easy, CURLOPT_NOPROGRESS, SHOW_PROGRESS?0L:1L);
+ curl_easy_setopt(conn->easy, CURLOPT_NOPROGRESS, SHOW_PROGRESS ? 0L : 1L);
curl_easy_setopt(conn->easy, CURLOPT_PROGRESSFUNCTION, prog_cb);
curl_easy_setopt(conn->easy, CURLOPT_PROGRESSDATA, conn);
curl_easy_setopt(conn->easy, CURLOPT_FOLLOWLOCATION, 1L);
/* walk the attribute list */
for(attr = tidyAttrFirst(child); attr; attr = tidyAttrNext(attr) ) {
printf("%s", tidyAttrName(attr));
- tidyAttrValue(attr)?printf("=\"%s\" ",
- tidyAttrValue(attr)):printf(" ");
+ tidyAttrValue(attr) ? printf("=\"%s\" ",
+ tidyAttrValue(attr)) : printf(" ");
}
printf(">\n");
}
TidyBuffer buf;
tidyBufInit(&buf);
tidyNodeGetText(doc, child, &buf);
- printf("%*.*s\n", indent, indent, buf.bp?(char *)buf.bp:"");
+ printf("%*.*s\n", indent, indent, buf.bp ? (char *)buf.bp : "");
tidyBufFree(&buf);
}
dumpNode(doc, child, indent + 4); /* recursive */
fprintf(stderr, "%u %s, %lu bytes (0x%lx)\n",
num, text, (unsigned long)size, (unsigned long)size);
- for(i = 0; i<size; i += width) {
+ for(i = 0; i < size; i += width) {
fprintf(stderr, "%4.4lx: ", (unsigned long)i);
break;
}
fprintf(stderr, "%c",
- (ptr[i + c] >= 0x20) && (ptr[i + c]<0x80)?ptr[i + c]:'.');
+ (ptr[i + c] >= 0x20) && (ptr[i + c] < 0x80) ? ptr[i + c] : '.');
/* check again for 0D0A, to avoid an extra \n if it's at width */
if(nohex && (i + c + 2 < size) && ptr[i + c + 1] == 0x0D &&
ptr[i + c + 2] == 0x0A) {
fprintf(stderr, "%s, %lu bytes (0x%lx)\n",
text, (unsigned long)size, (unsigned long)size);
- for(i = 0; i<size; i += width) {
+ for(i = 0; i < size; i += width) {
fprintf(stderr, "%4.4lx: ", (unsigned long)i);
break;
}
fprintf(stderr, "%c",
- (ptr[i + c] >= 0x20) && (ptr[i + c]<0x80)?ptr[i + c]:'.');
+ (ptr[i + c] >= 0x20) && (ptr[i + c] < 0x80) ? ptr[i + c] : '.');
/* check again for 0D0A, to avoid an extra \n if it's at width */
if(nohex && (i + c + 2 < size) && ptr[i + c + 1] == 0x0D &&
ptr[i + c + 2] == 0x0A) {
fprintf(stderr, "**** push callback approves stream %u, got %lu headers!\n",
count, (unsigned long)num_headers);
- for(i = 0; i<num_headers; i++) {
+ for(i = 0; i < num_headers; i++) {
headp = curl_pushheader_bynum(headers, i);
fprintf(stderr, "**** header %lu: %s\n", (unsigned long)i, headp);
}
fprintf(stderr, "%d %s, %lu bytes (0x%lx)\n",
num, text, (unsigned long)size, (unsigned long)size);
- for(i = 0; i<size; i += width) {
+ for(i = 0; i < size; i += width) {
fprintf(stderr, "%4.4lx: ", (unsigned long)i);
break;
}
fprintf(stderr, "%c",
- (ptr[i + c] >= 0x20) && (ptr[i + c]<0x80)?ptr[i + c]:'.');
+ (ptr[i + c] >= 0x20) && (ptr[i + c] < 0x80) ? ptr[i + c] : '.');
/* check again for 0D0A, to avoid an extra \n if it's at width */
if(nohex && (i + c + 2 < size) && ptr[i + c + 1] == 0x0D &&
ptr[i + c + 2] == 0x0A) {
/* init a multi stack */
multi_handle = curl_multi_init();
- for(i = 0; i<num_transfers; i++) {
+ for(i = 0; i < num_transfers; i++) {
setup(&trans[i], i, filename);
/* add the individual transfer */
curl_multi_cleanup(multi_handle);
- for(i = 0; i<num_transfers; i++) {
+ for(i = 0; i < num_transfers; i++) {
curl_multi_remove_handle(multi_handle, trans[i].hnd);
curl_easy_cleanup(trans[i].hnd);
}
int msgs_left; /* how many messages are left */
/* Allocate one CURL handle per transfer */
- for(i = 0; i<HANDLECOUNT; i++)
+ for(i = 0; i < HANDLECOUNT; i++)
handles[i] = curl_easy_init();
/* set the options (I left out a few, you get the point anyway) */
multi_handle = curl_multi_init();
/* add the individual transfers */
- for(i = 0; i<HANDLECOUNT; i++)
+ for(i = 0; i < HANDLECOUNT; i++)
curl_multi_add_handle(multi_handle, handles[i]);
while(still_running) {
int idx;
/* Find out which handle this message is about */
- for(idx = 0; idx<HANDLECOUNT; idx++) {
+ for(idx = 0; idx < HANDLECOUNT; idx++) {
int found = (msg->easy_handle == handles[idx]);
if(found)
break;
}
/* remove the transfers and cleanup the handles */
- for(i = 0; i<HANDLECOUNT; i++) {
+ for(i = 0; i < HANDLECOUNT; i++) {
curl_multi_remove_handle(multi_handle, handles[i]);
curl_easy_cleanup(handles[i]);
}
fprintf(stream, "%s, %10.10lu bytes (0x%8.8lx)\n",
text, (unsigned long)size, (unsigned long)size);
- for(i = 0; i<size; i += width) {
+ for(i = 0; i < size; i += width) {
fprintf(stream, "%4.4lx: ", (unsigned long)i);
break;
}
fprintf(stream, "%c",
- (ptr[i + c] >= 0x20) && (ptr[i + c]<0x80)?ptr[i + c]:'.');
+ (ptr[i + c] >= 0x20) && (ptr[i + c] < 0x80) ? ptr[i + c] : '.');
/* check again for 0D0A, to avoid an extra \n if it's at width */
if(nohex && (i + c + 2 < size) && ptr[i + c + 1] == 0x0D &&
ptr[i + c + 2] == 0x0A) {
int msgs_left; /* how many messages are left */
/* Allocate one CURL handle per transfer */
- for(i = 0; i<HANDLECOUNT; i++)
+ for(i = 0; i < HANDLECOUNT; i++)
handles[i] = curl_easy_init();
/* set the options (I left out a few, you get the point anyway) */
multi_handle = curl_multi_init();
/* add the individual transfers */
- for(i = 0; i<HANDLECOUNT; i++)
+ for(i = 0; i < HANDLECOUNT; i++)
curl_multi_add_handle(multi_handle, handles[i]);
/* we start some action by calling perform right away */
int idx;
/* Find out which handle this message is about */
- for(idx = 0; idx<HANDLECOUNT; idx++) {
+ for(idx = 0; idx < HANDLECOUNT; idx++) {
int found = (msg->easy_handle == handles[idx]);
if(found)
break;
curl_multi_cleanup(multi_handle);
/* Free the CURL handles */
- for(i = 0; i<HANDLECOUNT; i++)
+ for(i = 0; i < HANDLECOUNT; i++)
curl_easy_cleanup(handles[i]);
return 0;
/* Must initialize libcurl before any threads are started */
curl_global_init(CURL_GLOBAL_ALL);
- for(i = 0; i< NUMT; i++) {
+ for(i = 0; i < NUMT; i++) {
int error = pthread_create(&tid[i],
NULL, /* default attributes please */
pull_one_url,
}
/* now wait for all threads to terminate */
- for(i = 0; i< NUMT; i++) {
+ for(i = 0; i < NUMT; i++) {
pthread_join(tid[i], NULL);
fprintf(stderr, "Thread %d terminated\n", i);
}
if(RetVal == 7) {
int i;
SYSTime.wMilliseconds = 500; /* adjust to midpoint, 0.5 sec */
- for(i = 0; i<12; i++) {
+ for(i = 0; i < 12; i++) {
if(strcmp(MthStr[i], TmpStr2) == 0) {
SYSTime.wMonth = i + 1;
break;
int i;
*conf->http_proxy = 0;
- for(i = 0; i<MAX_STRING1; i++)
+ for(i = 0; i < MAX_STRING1; i++)
conf->proxy_user[i] = 0; /* Clean up password from memory */
*conf->timeserver = 0;
return 1;
/* Must initialize libcurl before any threads are started */
curl_global_init(CURL_GLOBAL_ALL);
- for(i = 0; i< NUMT; i++) {
+ for(i = 0; i < NUMT; i++) {
int error = pthread_create(&tid[i],
NULL, /* default attributes please */
pull_one_url,
}
/* now wait for all threads to terminate */
- for(i = 0; i< NUMT; i++) {
+ for(i = 0; i < NUMT; i++) {
pthread_join(tid[i], NULL);
fprintf(stderr, "Thread %d terminated\n", i);
}
/* move through the descriptors and ask for processing on them */
for(i = 0; i < num; i++)
ares_process_fd((ares_channel)data->state.async.resolver,
- (pfd[i].revents & (POLLRDNORM|POLLIN))?
- pfd[i].fd:ARES_SOCKET_BAD,
- (pfd[i].revents & (POLLWRNORM|POLLOUT))?
- pfd[i].fd:ARES_SOCKET_BAD);
+ (pfd[i].revents & (POLLRDNORM|POLLIN)) ?
+ pfd[i].fd : ARES_SOCKET_BAD,
+ (pfd[i].revents & (POLLWRNORM|POLLOUT)) ?
+ pfd[i].fd : ARES_SOCKET_BAD);
}
return nfds;
}
}
#endif /* CURLRES_IPV6 */
hints.ai_family = pf;
- hints.ai_socktype = (data->conn->transport == TRNSPRT_TCP)?
+ hints.ai_socktype = (data->conn->transport == TRNSPRT_TCP) ?
SOCK_STREAM : SOCK_DGRAM;
/* Since the service is a numerical one, set the hint flags
* accordingly to save a call to getservbyname in inside C-Ares
memset(&hints, 0, sizeof(hints));
hints.ai_family = pf;
- hints.ai_socktype = (data->conn->transport == TRNSPRT_TCP)?
+ hints.ai_socktype = (data->conn->transport == TRNSPRT_TCP) ?
SOCK_STREAM : SOCK_DGRAM;
reslv->start = Curl_now();
ssize_t n;
CURLcode result;
n = Curl_bufq_write(q, (const unsigned char *)buf, len, &result);
- *pnwritten = (n < 0)? 0 : (size_t)n;
+ *pnwritten = (n < 0) ? 0 : (size_t)n;
return result;
}
len -= chunk_unwrite(q->head, len);
prune_tail(q);
}
- return len? CURLE_AGAIN : CURLE_OK;
+ return len ? CURLE_AGAIN : CURLE_OK;
}
ssize_t Curl_bufq_read(struct bufq *q, unsigned char *buf, size_t len,
ssize_t n;
CURLcode result;
n = Curl_bufq_read(q, (unsigned char *)buf, len, &result);
- *pnread = (n < 0)? 0 : (size_t)n;
+ *pnread = (n < 0) ? 0 : (size_t)n;
return result;
}
/* We need to set 'httpcodeq' for functions that check the response code in
a single place. */
data->req.httpcode = http_status;
- data->req.httpversion = http_version == HYPER_HTTP_VERSION_1_1? 11 :
+ data->req.httpversion = http_version == HYPER_HTTP_VERSION_1_1 ? 11 :
(http_version == HYPER_HTTP_VERSION_2 ? 20 : 10);
if(data->state.hconnect)
/* CONNECT */
goto out;
k->deductheadercount =
- (100 <= http_status && 199 >= http_status)?k->headerbytecount:0;
+ (100 <= http_status && 199 >= http_status) ? k->headerbytecount : 0;
#ifdef USE_WEBSOCKETS
if(k->upgr101 == UPGR101_WS) {
if(http_status == 101) {
if(result)
return result;
- authority = aprintf("%s%s%s:%d", ipv6_ip?"[":"", hostname, ipv6_ip?"]":"",
- port);
+ authority = aprintf("%s%s%s:%d", ipv6_ip ? "[":"", hostname,
+ ipv6_ip ? "]" : "", port);
if(!authority)
return CURLE_OUT_OF_MEMORY;
return result;
ts->authority = /* host:port with IPv6 support */
- aprintf("%s%s%s:%d", ipv6_ip?"[":"", hostname, ipv6_ip?"]":"", port);
+ aprintf("%s%s%s:%d", ipv6_ip ? "[":"", hostname,
+ ipv6_ip ? "]" : "", port);
if(!ts->authority)
return CURLE_OUT_OF_MEMORY;
return result;
}
CURL_TRC_CF(data, cf, "[0] nw send buffer flushed");
- return Curl_bufq_is_empty(&ctx->outbufq)? CURLE_OK: CURLE_AGAIN;
+ return Curl_bufq_is_empty(&ctx->outbufq) ? CURLE_OK : CURLE_AGAIN;
}
/*
return msnprintf(buffer, blen,
"FRAME[SETTINGS, len=%d]", (int)frame->hd.length);
}
- case NGHTTP2_PUSH_PROMISE: {
+ case NGHTTP2_PUSH_PROMISE:
return msnprintf(buffer, blen,
"FRAME[PUSH_PROMISE, len=%d, hend=%d]",
(int)frame->hd.length,
!!(frame->hd.flags & NGHTTP2_FLAG_END_HEADERS));
- }
- case NGHTTP2_PING: {
+ case NGHTTP2_PING:
return msnprintf(buffer, blen,
"FRAME[PING, len=%d, ack=%d]",
(int)frame->hd.length,
- frame->hd.flags&NGHTTP2_FLAG_ACK);
- }
+ frame->hd.flags & NGHTTP2_FLAG_ACK);
case NGHTTP2_GOAWAY: {
char scratch[128];
size_t s_len = sizeof(scratch)/sizeof(scratch[0]);
- size_t len = (frame->goaway.opaque_data_len < s_len)?
- frame->goaway.opaque_data_len : s_len-1;
- if(len)
- memcpy(scratch, frame->goaway.opaque_data, len);
- scratch[len] = '\0';
- return msnprintf(buffer, blen, "FRAME[GOAWAY, error=%d, reason='%s', "
- "last_stream=%d]", frame->goaway.error_code,
- scratch, frame->goaway.last_stream_id);
+ size_t len = (frame->goaway.opaque_data_len < s_len) ?
+ frame->goaway.opaque_data_len : s_len-1;
+ if(len)
+ memcpy(scratch, frame->goaway.opaque_data, len);
+ scratch[len] = '\0';
+ return msnprintf(buffer, blen, "FRAME[GOAWAY, error=%d, reason='%s', "
+ "last_stream=%d]", frame->goaway.error_code,
+ scratch, frame->goaway.last_stream_id);
}
case NGHTTP2_WINDOW_UPDATE: {
return msnprintf(buffer, blen,
(ctx && ctx->tunnel.state == H2_TUNNEL_ESTABLISHED &&
!Curl_bufq_is_empty(&ctx->tunnel.recvbuf)))
return TRUE;
- return cf->next? cf->next->cft->has_data_pending(cf->next, data) : FALSE;
+ return cf->next ? cf->next->cft->has_data_pending(cf->next, data) : FALSE;
}
static void cf_h2_proxy_adjust_pollset(struct Curl_cfilter *cf,
default:
break;
}
- return cf->next?
+ return cf->next ?
cf->next->cft->query(cf->next, data, query, pres1, pres2) :
CURLE_UNKNOWN_OPTION;
}
client_ip = ipquad.local_ip;
result = Curl_dyn_addf(&ctx->data_out, "PROXY %s %s %s %i %i\r\n",
- is_ipv6? "TCP6" : "TCP4",
+ is_ipv6 ? "TCP6" : "TCP4",
client_ip, ipquad.remote_ip,
ipquad.local_port, ipquad.remote_port);
}
else if(ctx->h21_baller.enabled)
cf_hc_baller_init(&ctx->h21_baller, cf, data, "h21",
- cf->conn->transport);
+ cf->conn->transport);
ctx->state = CF_HC_CONNECT;
FALLTHROUGH();
(!ctx->h21_baller.enabled || ctx->h21_baller.result)) {
/* both failed or disabled. we give up */
CURL_TRC_CF(data, cf, "connect, all failed");
- result = ctx->result = ctx->h3_baller.enabled?
- ctx->h3_baller.result : ctx->h21_baller.result;
+ result = ctx->result = ctx->h3_baller.enabled ?
+ ctx->h3_baller.result : ctx->h21_baller.result;
ctx->state = CF_HC_FAILURE;
goto out;
}
memset(&tmax, 0, sizeof(tmax));
memset(&t, 0, sizeof(t));
- cfb = ctx->h21_baller.enabled? ctx->h21_baller.cf : NULL;
+ cfb = ctx->h21_baller.enabled ? ctx->h21_baller.cf : NULL;
if(cfb && !cfb->cft->query(cfb, data, query, NULL, &t)) {
if((t.tv_sec || t.tv_usec) && Curl_timediff_us(t, tmax) > 0)
tmax = t;
}
memset(&t, 0, sizeof(t));
- cfb = ctx->h3_baller.enabled? ctx->h3_baller.cf : NULL;
+ cfb = ctx->h3_baller.enabled ? ctx->h3_baller.cf : NULL;
if(cfb && !cfb->cft->query(cfb, data, query, NULL, &t)) {
if((t.tv_sec || t.tv_usec) && Curl_timediff_us(t, tmax) > 0)
tmax = t;
break;
}
}
- return cf->next?
+ return cf->next ?
cf->next->cft->query(cf->next, data, query, pres1, pres2) :
CURLE_UNKNOWN_OPTION;
}
tcpkeepalive(struct Curl_easy *data,
curl_socket_t sockfd)
{
- int optval = data->set.tcp_keepalive?1:0;
+ int optval = data->set.tcp_keepalive ? 1 : 0;
/* only set IDLE and INTVL if setting KEEPALIVE is successful */
if(setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE,
memset(&sa, 0, sizeof(struct Curl_sockaddr_storage));
- if(iface && (strlen(iface)<255) ) {
+ if(iface && (strlen(iface) < 255) ) {
char myhost[256] = "";
int done = 0; /* -1 for error, 1 for address found */
if2ip_result_t if2ip_result = IF2IP_NOT_FOUND;
cf->conn->primary = ctx->ip;
cf->conn->remote_addr = &ctx->addr;
#ifdef USE_IPV6
- cf->conn->bits.ipv6 = (ctx->addr.family == AF_INET6)? TRUE : FALSE;
+ cf->conn->bits.ipv6 = (ctx->addr.family == AF_INET6) ? TRUE : FALSE;
#endif
}
else {
case CF_QUERY_CONNECT_REPLY_MS:
if(ctx->got_first_byte) {
timediff_t ms = Curl_timediff(ctx->first_byte_at, ctx->started_at);
- *pres1 = (ms < INT_MAX)? (int)ms : INT_MAX;
+ *pres1 = (ms < INT_MAX) ? (int)ms : INT_MAX;
}
else
*pres1 = -1;
}
case CF_QUERY_IP_INFO:
#ifdef USE_IPV6
- *pres1 = (ctx->addr.family == AF_INET6)? TRUE : FALSE;
+ *pres1 = (ctx->addr.family == AF_INET6) ? TRUE : FALSE;
#else
*pres1 = FALSE;
#endif
default:
break;
}
- return cf->next?
+ return cf->next ?
cf->next->cft->query(cf->next, data, query, pres1, pres2) :
CURLE_UNKNOWN_OPTION;
}
result = Curl_cf_create(&cf, &Curl_cft_tcp, ctx);
out:
- *pcf = (!result)? cf : NULL;
+ *pcf = (!result) ? cf : NULL;
if(result) {
Curl_safefree(cf);
Curl_safefree(ctx);
set_local_ip(cf, data);
CURL_TRC_CF(data, cf, "%s socket %" FMT_SOCKET_T
" connected: [%s:%d] -> [%s:%d]",
- (ctx->transport == TRNSPRT_QUIC)? "QUIC" : "UDP",
+ (ctx->transport == TRNSPRT_QUIC) ? "QUIC" : "UDP",
ctx->sock, ctx->ip.local_ip, ctx->ip.local_port,
ctx->ip.remote_ip, ctx->ip.remote_port);
result = Curl_cf_create(&cf, &Curl_cft_udp, ctx);
out:
- *pcf = (!result)? cf : NULL;
+ *pcf = (!result) ? cf : NULL;
if(result) {
Curl_safefree(cf);
Curl_safefree(ctx);
result = Curl_cf_create(&cf, &Curl_cft_unix, ctx);
out:
- *pcf = (!result)? cf : NULL;
+ *pcf = (!result) ? cf : NULL;
if(result) {
Curl_safefree(cf);
Curl_safefree(ctx);
bool Curl_cf_def_data_pending(struct Curl_cfilter *cf,
const struct Curl_easy *data)
{
- return cf->next?
+ return cf->next ?
cf->next->cft->has_data_pending(cf->next, data) : FALSE;
}
const void *buf, size_t len, bool eos,
CURLcode *err)
{
- return cf->next?
+ return cf->next ?
cf->next->cft->do_send(cf->next, data, buf, len, eos, err) :
CURLE_RECV_ERROR;
}
ssize_t Curl_cf_def_recv(struct Curl_cfilter *cf, struct Curl_easy *data,
char *buf, size_t len, CURLcode *err)
{
- return cf->next?
+ return cf->next ?
cf->next->cft->do_recv(cf->next, data, buf, len, err) :
CURLE_SEND_ERROR;
}
struct Curl_easy *data,
bool *input_pending)
{
- return cf->next?
+ return cf->next ?
cf->next->cft->is_alive(cf->next, data, input_pending) :
FALSE; /* pessimistic in absence of data */
}
CURLcode Curl_cf_def_conn_keep_alive(struct Curl_cfilter *cf,
struct Curl_easy *data)
{
- return cf->next?
+ return cf->next ?
cf->next->cft->keep_alive(cf->next, data) :
CURLE_OK;
}
struct Curl_easy *data,
int query, int *pres1, void *pres2)
{
- return cf->next?
+ return cf->next ?
cf->next->cft->query(cf->next, data, query, pres1, pres2) :
CURLE_UNKNOWN_OPTION;
}
now = Curl_now();
if(!Curl_shutdown_started(data, sockindex)) {
DEBUGF(infof(data, "shutdown start on%s connection",
- sockindex? " secondary" : ""));
+ sockindex ? " secondary" : ""));
Curl_shutdown_start(data, sockindex, &now);
}
else {
bool Curl_conn_is_ssl(struct connectdata *conn, int sockindex)
{
- return conn? Curl_conn_cf_is_ssl(conn->cfilter[sockindex]) : FALSE;
+ return conn ? Curl_conn_cf_is_ssl(conn->cfilter[sockindex]) : FALSE;
}
bool Curl_conn_is_multiplex(struct connectdata *conn, int sockindex)
{
- struct Curl_cfilter *cf = conn? conn->cfilter[sockindex] : NULL;
+ struct Curl_cfilter *cf = conn ? conn->cfilter[sockindex] : NULL;
for(; cf; cf = cf->next) {
if(cf->cft->flags & CF_TYPE_MULTIPLEX)
{
CURLcode result;
int pending = FALSE;
- result = cf? cf->cft->query(cf, data, CF_QUERY_NEED_FLUSH,
- &pending, NULL) : CURLE_UNKNOWN_OPTION;
- return (result || pending == FALSE)? FALSE : TRUE;
+ result = cf ? cf->cft->query(cf, data, CF_QUERY_NEED_FLUSH,
+ &pending, NULL) : CURLE_UNKNOWN_OPTION;
+ return (result || pending == FALSE) ? FALSE : TRUE;
}
bool Curl_conn_needs_flush(struct Curl_easy *data, int sockindex)
{
struct Curl_cfilter *cf;
- cf = data->conn? data->conn->cfilter[sockindex] : NULL;
+ cf = data->conn ? data->conn->cfilter[sockindex] : NULL;
/* if the top filter has not connected, ask it (and its sub-filters)
* for the socket. Otherwise conn->sock[sockindex] should have it.
*/
if(cf && !cf->connected)
return Curl_conn_cf_get_socket(cf, data);
- return data->conn? data->conn->sock[sockindex] : CURL_SOCKET_BAD;
+ return data->conn ? data->conn->sock[sockindex] : CURL_SOCKET_BAD;
}
void Curl_conn_forget_socket(struct Curl_easy *data, int sockindex)
int sockindex)
{
struct Curl_cfilter *cf = conn->cfilter[sockindex];
- return cf? cf->cft->keep_alive(cf, data) : CURLE_OK;
+ return cf ? cf->cft->keep_alive(cf, data) : CURLE_OK;
}
size_t Curl_conn_get_max_concurrent(struct Curl_easy *data,
int n = 0;
struct Curl_cfilter *cf = conn->cfilter[sockindex];
- result = cf? cf->cft->query(cf, data, CF_QUERY_MAX_CONCURRENT,
- &n, NULL) : CURLE_UNKNOWN_OPTION;
- return (result || n <= 0)? 1 : (size_t)n;
+ result = cf ? cf->cft->query(cf, data, CF_QUERY_MAX_CONCURRENT,
+ &n, NULL) : CURLE_UNKNOWN_OPTION;
+ return (result || n <= 0) ? 1 : (size_t)n;
}
int Curl_conn_get_stream_error(struct Curl_easy *data,
int n = 0;
struct Curl_cfilter *cf = conn->cfilter[sockindex];
- result = cf? cf->cft->query(cf, data, CF_QUERY_STREAM_ERROR,
- &n, NULL) : CURLE_UNKNOWN_OPTION;
- return (result || n < 0)? 0 : n;
+ result = cf ? cf->cft->query(cf, data, CF_QUERY_STREAM_ERROR,
+ &n, NULL) : CURLE_UNKNOWN_OPTION;
+ return (result || n < 0) ? 0 : n;
}
int Curl_conn_sockindex(struct Curl_easy *data, curl_socket_t sockfd)
nread = data->conn->recv[sockindex](data, sockindex, buf, blen, &result);
DEBUGASSERT(nread >= 0 || result);
DEBUGASSERT(nread < 0 || !result);
- *n = (nread >= 0)? (size_t)nread : 0;
+ *n = (nread >= 0) ? (size_t)nread : 0;
return result;
}
nwritten = conn->send[sockindex](data, sockindex, buf, write_len, eos,
&result);
DEBUGASSERT((nwritten >= 0) || result);
- *pnwritten = (nwritten < 0)? 0 : (size_t)nwritten;
+ *pnwritten = (nwritten < 0) ? 0 : (size_t)nwritten;
return result;
}
size_t i;
(void)data;
memset(ps, 0, sizeof(*ps));
- for(i = 0; i< MAX_SOCKSPEREASYHANDLE; i++)
+ for(i = 0; i < MAX_SOCKSPEREASYHANDLE; i++)
ps->sockets[i] = CURL_SOCKET_BAD;
}
bool do_in, bool do_out)
{
Curl_pollset_change(data, ps, sock,
- (do_in?CURL_POLL_IN:0)|(do_out?CURL_POLL_OUT:0),
- (!do_in?CURL_POLL_IN:0)|(!do_out?CURL_POLL_OUT:0));
+ (do_in ? CURL_POLL_IN : 0)|
+ (do_out ? CURL_POLL_OUT : 0),
+ (!do_in ? CURL_POLL_IN : 0)|
+ (!do_out ? CURL_POLL_OUT : 0));
}
static void ps_add(struct Curl_easy *data, struct easy_pollset *ps,
struct connectdata *conn)
{
unsigned int maxconnects = !data->multi->maxconnects ?
- data->multi->num_easy * 4: data->multi->maxconnects;
+ data->multi->num_easy * 4 : data->multi->maxconnects;
struct connectdata *oldest_idle = NULL;
struct cpool *cpool = cpool_get_instance(data);
bool kept = TRUE;
if(data->multi) {
/* Add it to the multi's cpool for shutdown handling */
infof(data, "%s connection #%" FMT_OFF_T,
- aborted? "closing" : "shutting down", conn->connection_id);
+ aborted ? "closing" : "shutting down", conn->connection_id);
cpool_discard_conn(&data->multi->cpool, data, conn, aborted);
}
else {
timespent = Curl_timediff(Curl_now(), started);
if(timespent >= (timediff_t)timeout_ms) {
DEBUGF(infof(data, "cpool shutdown %s",
- (timeout_ms > 0)? "timeout" : "best effort done"));
+ (timeout_ms > 0) ? "timeout" : "best effort done"));
break;
}
return ctimeleft_ms; /* no general timeout, this is it */
}
/* return minimal time left or max amount already expired */
- return (ctimeleft_ms < timeleft_ms)? ctimeleft_ms : timeleft_ms;
+ return (ctimeleft_ms < timeleft_ms) ? ctimeleft_ms : timeleft_ms;
}
void Curl_shutdown_start(struct Curl_easy *data, int sockindex,
}
left_ms = conn->shutdown.timeout_ms -
Curl_timediff(*nowp, conn->shutdown.start[sockindex]);
- return left_ms? left_ms : -1;
+ return left_ms ? left_ms : -1;
}
timediff_t Curl_conn_shutdown_timeleft(struct connectdata *conn,
if(!baller)
return CURLE_OUT_OF_MEMORY;
- baller->name = ((ai_family == AF_INET)? "ipv4" : (
+ baller->name = ((ai_family == AF_INET) ? "ipv4" : (
#ifdef USE_IPV6
- (ai_family == AF_INET6)? "ipv6" :
+ (ai_family == AF_INET6) ? "ipv6" :
#endif
"ip"));
baller->cf_create = cf_create;
baller->ai_family = ai_family;
baller->primary = primary;
baller->delay_ms = delay_ms;
- baller->timeoutms = addr_next_match(baller->addr, baller->ai_family)?
+ baller->timeoutms = addr_next_match(baller->addr, baller->ai_family) ?
USETIME(timeout_ms) : timeout_ms;
baller->timeout_id = timeout_id;
baller->result = CURLE_COULDNT_CONNECT;
}
}
- return cf->next?
+ return cf->next ?
cf->next->cft->query(cf->next, data, query, pres1, pres2) :
CURLE_UNKNOWN_OPTION;
}
{
z_stream *z = &zp->z;
CURLcode result = CURLE_OK;
- uInt len = z->avail_in < zp->trailerlen? z->avail_in: zp->trailerlen;
+ uInt len = z->avail_in < zp->trailerlen ? z->avail_in : zp->trailerlen;
/* Consume expected trailer bytes. Terminate stream if exhausted.
Issue an error if unexpected bytes follow. */
(void) data;
bp->br = BrotliDecoderCreateInstance(NULL, NULL, NULL);
- return bp->br? CURLE_OK: CURLE_OUT_OF_MEMORY;
+ return bp->br ? CURLE_OK : CURLE_OUT_OF_MEMORY;
}
static CURLcode brotli_do_write(struct Curl_easy *data,
CURLcode Curl_build_unencoding_stack(struct Curl_easy *data,
const char *enclist, int is_transfer)
{
- Curl_cwriter_phase phase = is_transfer?
- CURL_CW_TRANSFER_DECODE:CURL_CW_CONTENT_DECODE;
+ Curl_cwriter_phase phase = is_transfer ?
+ CURL_CW_TRANSFER_DECODE : CURL_CW_CONTENT_DECODE;
CURLcode result;
do {
struct Curl_cwriter *writer;
CURL_TRC_WRITE(data, "looking for %s decoder: %.*s",
- is_transfer? "transfer" : "content", (int)namelen, name);
+ is_transfer ? "transfer" : "content", (int)namelen, name);
is_chunked = (is_transfer && (namelen == 7) &&
strncasecompare(name, "chunked", 7));
/* if we skip the decoding in this phase, do not look further.
result = Curl_cwriter_create(&writer, data, cwt, phase);
CURL_TRC_WRITE(data, "added %s decoder %s -> %d",
- is_transfer? "transfer" : "content", cwt->name, result);
+ is_transfer ? "transfer" : "content", cwt->name, result);
if(result)
return result;
if(outlen)
*outlen = len;
- return first? first: domain;
+ return first ? first : domain;
}
/* Avoid C1001, an "internal error" with MSVC14 */
*/
CURLofft offt;
const char *maxage = valuep;
- offt = curlx_strtoofft((*maxage == '\"')?
- &maxage[1]:&maxage[0], NULL, 10,
+ offt = curlx_strtoofft((*maxage == '\"') ?
+ &maxage[1] : &maxage[0], NULL, 10,
&co->expires);
switch(offt) {
case CURL_OFFT_FLOW:
/* Only show this when NOT reading the cookies from a file */
infof(data, "%s cookie %s=\"%s\" for domain %s, path %s, "
"expire %" FMT_OFF_T,
- replace_old?"Replaced":"Added", co->name, co->value,
+ replace_old ? "Replaced":"Added", co->name, co->value,
co->domain, co->path, co->expires);
if(!replace_old) {
/* remake the linked list order according to the new order */
mainco = array[0]; /* start here */
- for(i = 0; i<matches-1; i++)
+ for(i = 0; i < matches-1; i++)
array[i]->next = array[i + 1];
array[matches-1]->next = NULL; /* terminate the list */
"%" FMT_OFF_T "\t" /* expires */
"%s\t" /* name */
"%s", /* value */
- co->httponly?"#HttpOnly_":"",
+ co->httponly ? "#HttpOnly_" : "",
/*
* Make sure all domains are prefixed with a dot if they allow
* tailmatching. This is Mozilla-style.
*/
- (co->tailmatch && co->domain && co->domain[0] != '.')? ".":"",
- co->domain?co->domain:"unknown",
- co->tailmatch?"TRUE":"FALSE",
- co->path?co->path:"/",
- co->secure?"TRUE":"FALSE",
+ (co->tailmatch && co->domain && co->domain[0] != '.') ? "." : "",
+ co->domain ? co->domain : "unknown",
+ co->tailmatch ? "TRUE" : "FALSE",
+ co->path ? co->path : "/",
+ co->secure ? "TRUE" : "FALSE",
co->expires,
co->name,
- co->value?co->value:"");
+ co->value ? co->value : "");
}
/*
p++;
break;
case '\0':
- return *s? CURL_FNMATCH_NOMATCH: CURL_FNMATCH_MATCH;
+ return *s ? CURL_FNMATCH_NOMATCH : CURL_FNMATCH_MATCH;
case '\\':
if(p[1])
p++;
134774 days = 11644473600 seconds = 0x2B6109100 */
r = ft->dwLowDateTime;
ft->dwLowDateTime = (ft->dwLowDateTime + 0xB6109100U) & 0xFFFFFFFF;
- ft->dwHighDateTime += ft->dwLowDateTime < r? 0x03: 0x02;
+ ft->dwHighDateTime += ft->dwLowDateTime < r ? 0x03 : 0x02;
/* Convert to tenths of microseconds. */
ft->dwHighDateTime *= 10000000;
CURLcode Curl_trc_opt(const char *config)
{
- CURLcode result = config? trc_opt(config) : CURLE_OK;
+ CURLcode result = config ? trc_opt(config) : CURLE_OK;
#ifdef DEBUGBUILD
/* CURL_DEBUG can override anything */
if(!result) {
*pmin_write = 0;
break;
case CW_OUT_HDS:
- *pwcb = data->set.fwrite_header? data->set.fwrite_header :
- (data->set.writeheader? data->set.fwrite_func : NULL);
+ *pwcb = data->set.fwrite_header ? data->set.fwrite_header :
+ (data->set.writeheader ? data->set.fwrite_func : NULL);
*pwcb_data = data->set.writeheader;
*pmax_write = 0; /* do not chunk-write headers, write them as they are */
*pmin_write = 0;
while(blen && !ctx->paused) {
if(!flush_all && blen < min_write)
break;
- wlen = max_write? CURLMIN(blen, max_write) : blen;
+ wlen = max_write ? CURLMIN(blen, max_write) : blen;
Curl_set_in_callback(data, TRUE);
nwritten = wcb((char *)buf, 1, wlen, wcb_data);
Curl_set_in_callback(data, FALSE);
CURL_TRC_WRITE(data, "cw_out, wrote %zu %s bytes -> %zu",
- wlen, (otype == CW_OUT_BODY)? "body" : "header",
+ wlen, (otype == CW_OUT_BODY) ? "body" : "header",
nwritten);
if(CURL_WRITEFUNC_PAUSE == nwritten) {
if(data->conn && data->conn->handler->flags & PROTOPT_NONETWORK) {
return FALSE;
ctx = (struct cw_out_ctx *)cw_out;
- CURL_TRC_WRITE(data, "cw-out is%spaused", ctx->paused? "" : " not");
+ CURL_TRC_WRITE(data, "cw-out is%spaused", ctx->paused ? "" : " not");
return ctx->paused;
}
*dnsp++ = 0; /* append zero-length label for root */
/* There are assigned TYPE codes beyond 255: use range [1..65535] */
- *dnsp++ = (unsigned char)(255 & (dnstype>>8)); /* upper 8 bit TYPE */
+ *dnsp++ = (unsigned char)(255 & (dnstype >> 8)); /* upper 8 bit TYPE */
*dnsp++ = (unsigned char)(255 & dnstype); /* lower 8 bit TYPE */
*dnsp++ = '\0'; /* upper 8 bit CLASS */
len = sizeof(buffer) - len;
for(j = 0; j < 16; j += 2) {
size_t l;
- msnprintf(ptr, len, "%s%02x%02x", j?":":"", d->addr[i].ip.v6[j],
+ msnprintf(ptr, len, "%s%02x%02x", j ? ":" : "", d->addr[i].ip.v6[j],
d->addr[i].ip.v6[j + 1]);
l = strlen(ptr);
len -= l;
if(dohp->probe[DOH_SLOT_IPV4].easy_mid < 0 &&
dohp->probe[DOH_SLOT_IPV6].easy_mid < 0) {
failf(data, "Could not DoH-resolve: %s", data->state.async.hostname);
- return CONN_IS_PROXIED(data->conn)?CURLE_COULDNT_RESOLVE_PROXY:
+ return CONN_IS_PROXIED(data->conn) ? CURLE_COULDNT_RESOLVE_PROXY :
CURLE_COULDNT_RESOLVE_HOST;
}
else if(!dohp->pending) {
doh->probe[slot].easy_mid = -1;
/* should have been called before data is removed from multi handle */
DEBUGASSERT(data->multi);
- probe_data = data->multi? Curl_multi_get_handle(data->multi, mid) : NULL;
+ probe_data = data->multi ? Curl_multi_get_handle(data->multi, mid) :
+ NULL;
if(!probe_data) {
DEBUGF(infof(data, "Curl_doh_close: xfer for mid=%"
FMT_OFF_T " not found!",
struct dynhds_entry *Curl_dynhds_getn(struct dynhds *dynhds, size_t n)
{
DEBUGASSERT(dynhds);
- return (n < dynhds->hds_len)? dynhds->hds[n] : NULL;
+ return (n < dynhds->hds_len) ? dynhds->hds[n] : NULL;
}
struct dynhds_entry *Curl_dynhds_get(struct dynhds *dynhds, const char *name,
CURLcode Curl_dynhds_h1_cadd_line(struct dynhds *dynhds, const char *line)
{
- return Curl_dynhds_h1_add_line(dynhds, line, line? strlen(line) : 0);
+ return Curl_dynhds_h1_add_line(dynhds, line, line ? strlen(line) : 0);
}
#ifdef UNITTESTS
m->socket.events = socketcb2poll(what);
infof(easy, "socket cb: socket %" FMT_SOCKET_T
" UPDATED as %s%s", s,
- (what&CURL_POLL_IN)?"IN":"",
- (what&CURL_POLL_OUT)?"OUT":"");
+ (what&CURL_POLL_IN) ? "IN" : "",
+ (what&CURL_POLL_OUT) ? "OUT" : "");
}
break;
}
m->socket.revents = 0;
ev->list = m;
infof(easy, "socket cb: socket %" FMT_SOCKET_T " ADDED as %s%s", s,
- (what&CURL_POLL_IN)?"IN":"",
- (what&CURL_POLL_OUT)?"OUT":"");
+ (what&CURL_POLL_IN) ? "IN" : "",
+ (what&CURL_POLL_OUT) ? "OUT" : "");
}
else
return CURLE_OUT_OF_MEMORY;
DEBUGASSERT(data);
/* loop over the monitored sockets to see which ones had activity */
- for(i = 0; i< numfds; i++) {
+ for(i = 0; i < numfds; i++) {
if(fds[i].revents) {
/* socket activity, tell libcurl */
int act = poll2cselect(fds[i].revents); /* convert */
memset(dst->set.blobs, 0, BLOB_LAST * sizeof(struct curl_blob *));
/* duplicate all strings */
- for(i = (enum dupstring)0; i< STRING_LASTZEROTERMINATED; i++) {
+ for(i = (enum dupstring)0; i < STRING_LASTZEROTERMINATED; i++) {
result = Curl_setstropt(&dst->set.str[i], src->set.str[i]);
if(result)
return result;
/* first switch off both pause bits then set the new pause bits */
newstate = (k->keepon &~ (KEEP_RECV_PAUSE| KEEP_SEND_PAUSE)) |
- ((action & CURLPAUSE_RECV)?KEEP_RECV_PAUSE:0) |
- ((action & CURLPAUSE_SEND)?KEEP_SEND_PAUSE:0);
+ ((action & CURLPAUSE_RECV) ? KEEP_RECV_PAUSE : 0) |
+ ((action & CURLPAUSE_SEND) ? KEEP_SEND_PAUSE : 0);
keep_changed = ((newstate & (KEEP_RECV_PAUSE| KEEP_SEND_PAUSE)) != oldstate);
not_all_paused = (newstate & (KEEP_RECV_PAUSE|KEEP_SEND_PAUSE)) !=
if(!string || (inlength < 0))
return NULL;
- length = (inlength?(size_t)inlength:strlen(string));
+ length = (inlength ? (size_t)inlength : strlen(string));
if(!length)
return strdup("");
/* encode it */
const char hex[] = "0123456789ABCDEF";
char out[3]={'%'};
- out[1] = hex[in>>4];
+ out[1] = hex[in >> 4];
out[2] = hex[in & 0xf];
if(Curl_dyn_addn(&d, out, 3))
return NULL;
while(len-- && (olen >= 3)) {
/* clang-tidy warns on this line without this comment: */
/* NOLINTNEXTLINE(clang-analyzer-core.UndefinedBinaryOperatorResult) */
- *out++ = (unsigned char)hex[(*src & 0xF0)>>4];
+ *out++ = (unsigned char)hex[(*src & 0xF0) >> 4];
*out++ = (unsigned char)hex[*src & 0x0F];
++src;
olen -= 2;
headerlen =
msnprintf(header, sizeof(header),
"Last-Modified: %s, %02d %s %4d %02d:%02d:%02d GMT\r\n",
- Curl_wkday[tm->tm_wday?tm->tm_wday-1:6],
+ Curl_wkday[tm->tm_wday ? tm->tm_wday-1 : 6],
tm->tm_mday,
Curl_month[tm->tm_mon],
tm->tm_year + 1900,
if(current_form->name)
return_value = CURL_FORMADD_OPTION_TWICE;
else {
- char *name = array_state?
- array_value:va_arg(params, char *);
+ char *name = array_state ?
+ array_value : va_arg(params, char *);
if(name)
current_form->name = name; /* store for the moment */
else
return_value = CURL_FORMADD_OPTION_TWICE;
else
current_form->namelength =
- array_state?(size_t)array_value:(size_t)va_arg(params, long);
+ array_state ? (size_t)array_value : (size_t)va_arg(params, long);
break;
/*
return_value = CURL_FORMADD_OPTION_TWICE;
else {
char *value =
- array_state?array_value:va_arg(params, char *);
+ array_state ? array_value : va_arg(params, char *);
if(value)
current_form->value = value; /* store for the moment */
else
break;
case CURLFORM_CONTENTSLENGTH:
current_form->contentslength =
- array_state?(size_t)array_value:(size_t)va_arg(params, long);
+ array_state ? (size_t)array_value : (size_t)va_arg(params, long);
break;
case CURLFORM_CONTENTLEN:
current_form->flags |= CURL_HTTPPOST_LARGE;
current_form->contentslength =
- array_state?(curl_off_t)(size_t)array_value:va_arg(params, curl_off_t);
+ array_state ? (curl_off_t)(size_t)array_value :
+ va_arg(params, curl_off_t);
break;
/* Get contents from a given filename */
if(current_form->flags & (HTTPPOST_PTRCONTENTS|HTTPPOST_READFILE))
return_value = CURL_FORMADD_OPTION_TWICE;
else {
- const char *filename = array_state?
- array_value:va_arg(params, char *);
+ const char *filename = array_state ?
+ array_value : va_arg(params, char *);
if(filename) {
current_form->value = strdup(filename);
if(!current_form->value)
/* We upload a file */
case CURLFORM_FILE:
{
- const char *filename = array_state?array_value:
+ const char *filename = array_state ? array_value :
va_arg(params, char *);
if(current_form->value) {
return_value = CURL_FORMADD_OPTION_TWICE;
else {
char *buffer =
- array_state?array_value:va_arg(params, char *);
+ array_state ? array_value : va_arg(params, char *);
if(buffer) {
current_form->buffer = buffer; /* store for the moment */
current_form->value = buffer; /* make it non-NULL to be accepted
return_value = CURL_FORMADD_OPTION_TWICE;
else
current_form->bufferlength =
- array_state?(size_t)array_value:(size_t)va_arg(params, long);
+ array_state ? (size_t)array_value : (size_t)va_arg(params, long);
break;
case CURLFORM_STREAM:
return_value = CURL_FORMADD_OPTION_TWICE;
else {
char *userp =
- array_state?array_value:va_arg(params, char *);
+ array_state ? array_value : va_arg(params, char *);
if(userp) {
current_form->userp = userp;
current_form->value = userp; /* this is not strictly true but we
case CURLFORM_CONTENTTYPE:
{
const char *contenttype =
- array_state?array_value:va_arg(params, char *);
+ array_state ? array_value : va_arg(params, char *);
if(current_form->contenttype) {
if(current_form->flags & HTTPPOST_FILENAME) {
if(contenttype) {
{
/* this "cast increases required alignment of target type" but
we consider it OK anyway */
- struct curl_slist *list = array_state?
- (struct curl_slist *)(void *)array_value:
+ struct curl_slist *list = array_state ?
+ (struct curl_slist *)(void *)array_value :
va_arg(params, struct curl_slist *);
if(current_form->contentheader)
case CURLFORM_FILENAME:
case CURLFORM_BUFFER:
{
- const char *filename = array_state?array_value:
+ const char *filename = array_state ? array_value :
va_arg(params, char *);
if(current_form->showfilename)
return_value = CURL_FORMADD_OPTION_TWICE;
if(((form->flags & HTTPPOST_FILENAME) ||
(form->flags & HTTPPOST_BUFFER)) &&
!form->contenttype) {
- char *f = (form->flags & HTTPPOST_BUFFER)?
+ char *f = (form->flags & HTTPPOST_BUFFER) ?
form->showfilename : form->value;
char const *type;
type = Curl_mime_contenttype(f);
app passed in a bad combo, so we better check for that first. */
if(form->name) {
/* copy name (without strdup; possibly not null-terminated) */
- form->name = Curl_memdup0(form->name, form->namelength?
- form->namelength:
+ form->name = Curl_memdup0(form->name, form->namelength ?
+ form->namelength :
strlen(form->name));
}
if(!form->name) {
}
else if(post->flags & HTTPPOST_BUFFER)
result = curl_mime_data(part, post->buffer,
- post->bufferlength? post->bufferlength: -1);
+ post->bufferlength ?
+ post->bufferlength : -1);
else if(post->flags & HTTPPOST_CALLBACK) {
/* the contents should be read with the callback and the size is set
with the contentslength */
else {
/* Add timeout to multi handle and break out of the loop */
Curl_expire(data, data->set.accepttimeout ?
- data->set.accepttimeout: DEFAULT_ACCEPT_TIMEOUT,
+ data->set.accepttimeout : DEFAULT_ACCEPT_TIMEOUT,
EXPIRE_FTP_ACCEPT);
}
*/
}
else if(!Curl_conn_data_pending(data, FIRSTSOCKET)) {
- curl_socket_t wsock = Curl_pp_needs_flush(data, pp)?
- sockfd : CURL_SOCKET_BAD;
+ curl_socket_t wsock = Curl_pp_needs_flush(data, pp) ?
+ sockfd : CURL_SOCKET_BAD;
int ev = Curl_socket_check(sockfd, CURL_SOCKET_BAD, wsock, interval_ms);
if(ev < 0) {
failf(data, "FTP response aborted due to select/poll error: %d",
{
CURLcode result = Curl_pp_sendf(data,
&conn->proto.ftpc.pp, "USER %s",
- conn->user?conn->user:"");
+ conn->user ? conn->user : "");
if(!result) {
struct ftp_conn *ftpc = &conn->proto.ftpc;
ftpc->ftp_trying_alternative = FALSE;
*/
result = Curl_pp_sendf(data, &ftpc->pp, "%s |%d|%s|%hu|", mode[fcmd],
- sa->sa_family == AF_INET?1:2,
+ sa->sa_family == AF_INET ? 1 : 2,
myhost, port);
if(result) {
failf(data, "Failure sending EPRT command: %s",
source++;
}
*dest = 0;
- msnprintf(dest, 20, ",%d,%d", (int)(port>>8), (int)(port&0xff));
+ msnprintf(dest, 20, ",%d,%d", (int)(port >> 8), (int)(port & 0xff));
result = Curl_pp_sendf(data, &ftpc->pp, "%s %s", mode[fcmd], target);
if(result) {
conn->bits.ftp_use_epsv = TRUE;
#endif
- modeoff = conn->bits.ftp_use_epsv?0:1;
+ modeoff = conn->bits.ftp_use_epsv ? 0 : 1;
result = Curl_pp_sendf(data, &ftpc->pp, "%s", mode[modeoff]);
if(!result) {
if(!conn->proto.ftpc.file)
result = Curl_pp_sendf(data, &ftpc->pp, "PRET %s",
data->set.str[STRING_CUSTOMREQUEST]?
- data->set.str[STRING_CUSTOMREQUEST]:
- (data->state.list_only?"NLST":"LIST"));
+ data->set.str[STRING_CUSTOMREQUEST] :
+ (data->state.list_only ? "NLST" : "LIST"));
else if(data->state.upload)
result = Curl_pp_sendf(data, &ftpc->pp, "PRET STOR %s",
conn->proto.ftpc.file);
cmd = aprintf("%s%s%s",
data->set.str[STRING_CUSTOMREQUEST]?
- data->set.str[STRING_CUSTOMREQUEST]:
- (data->state.list_only?"NLST":"LIST"),
- lstArg? " ": "",
- lstArg? lstArg: "");
+ data->set.str[STRING_CUSTOMREQUEST] :
+ (data->state.list_only ? "NLST" : "LIST"),
+ lstArg ? " " : "",
+ lstArg ? lstArg : "");
free(lstArg);
if(!cmd)
} while(passed < data->state.resume_from);
}
/* now, decrease the size of the read */
- if(data->state.infilesize>0) {
+ if(data->state.infilesize > 0) {
data->state.infilesize -= data->state.resume_from;
if(data->state.infilesize <= 0) {
/* we have passed, proceed as normal */
} /* resume_from */
- result = Curl_pp_sendf(data, &ftpc->pp, append?"APPE %s":"STOR %s",
+ result = Curl_pp_sendf(data, &ftpc->pp, append ? "APPE %s" : "STOR %s",
ftpc->file);
if(!result)
ftp_state(data, FTP_STOR);
int i = 0;
/* Skip count1 items in the linked list */
- while((i< ftpc->count1) && item) {
+ while((i < ftpc->count1) && item) {
item = item->next;
i++;
}
if(!ftpc->newhost)
return CURLE_OUT_OF_MEMORY;
- ftpc->newport = (unsigned short)(((ip[4]<<8) + ip[5]) & 0xffff);
+ ftpc->newport = (unsigned short)(((ip[4] << 8) + ip[5]) & 0xffff);
}
else if(ftpc->count1 == 0) {
/* EPSV failed, move on to PASV */
}
result = Curl_conn_setup(data, conn, SECONDARYSOCKET, addr,
- conn->bits.ftp_use_data_ssl?
+ conn->bits.ftp_use_data_ssl ?
CURL_CF_SSL_ENABLE : CURL_CF_SSL_DISABLE);
if(result) {
return result;
/* format: "Tue, 15 Nov 1994 12:45:26" */
- headerbuflen = msnprintf(headerbuf, sizeof(headerbuf),
- "Last-Modified: %s, %02d %s %4d %02d:%02d:%02d GMT\r\n",
- Curl_wkday[tm->tm_wday?tm->tm_wday-1:6],
- tm->tm_mday,
- Curl_month[tm->tm_mon],
- tm->tm_year + 1900,
- tm->tm_hour,
- tm->tm_min,
- tm->tm_sec);
+ headerbuflen =
+ msnprintf(headerbuf, sizeof(headerbuf),
+ "Last-Modified: %s, %02d %s %4d %02d:%02d:%02d GMT\r\n",
+ Curl_wkday[tm->tm_wday ? tm->tm_wday-1 : 6],
+ tm->tm_mday,
+ Curl_month[tm->tm_mon],
+ tm->tm_year + 1900,
+ tm->tm_hour,
+ tm->tm_min,
+ tm->tm_sec);
result = client_write_header(data, headerbuf, headerbuflen);
if(result)
return result;
else {
/* We got a file size report, so we check that there actually is a
part of the file left to get, or else we go home. */
- if(data->state.resume_from< 0) {
+ if(data->state.resume_from < 0) {
/* We are supposed to download the last abs(from) bytes */
if(filesize < -data->state.resume_from) {
failf(data, "Offset (%" FMT_OFF_T
}
else {
failf(data, "RETR response: %03d", ftpcode);
- return instate == FTP_RETR && ftpcode == 550?
- CURLE_REMOTE_FILE_NOT_FOUND:
+ return instate == FTP_RETR && ftpcode == 550 ?
+ CURLE_REMOTE_FILE_NOT_FOUND :
CURLE_FTP_COULDNT_RETR_FILE;
}
}
/* 331 Password required for ...
(the server requires to send the user's password too) */
result = Curl_pp_sendf(data, &ftpc->pp, "PASS %s",
- conn->passwd?conn->passwd:"");
+ conn->passwd ? conn->passwd : "");
if(!result)
ftp_state(data, FTP_PASS);
}
if(data->set.ftp_filemethod == FTPFILE_NOCWD)
pathLen = 0; /* relative path => working directory is FTP home */
else
- pathLen -= ftpc->file?strlen(ftpc->file):0; /* file is url-decoded */
+ /* file is url-decoded */
+ pathLen -= ftpc->file ? strlen(ftpc->file) : 0;
rawPath[pathLen] = '\0';
ftpc->prevpath = rawPath;
}
else if(!ftpc->dont_check &&
!data->req.bytecount &&
- (data->req.size>0)) {
+ (data->req.size > 0)) {
failf(data, "No data was received");
result = CURLE_FTP_COULDNT_RETR_FILE;
}
static int ftp_need_type(struct connectdata *conn,
bool ascii_wanted)
{
- return conn->proto.ftpc.transfertype != (ascii_wanted?'A':'I');
+ return conn->proto.ftpc.transfertype != (ascii_wanted ? 'A' : 'I');
}
/***********************************************************************
{
struct ftp_conn *ftpc = &conn->proto.ftpc;
CURLcode result;
- char want = (char)(ascii?'A':'I');
+ char want = (char)(ascii ? 'A' : 'I');
if(ftpc->transfertype == want) {
ftp_state(data, newstate);
if(data->set.ftp_filemethod == FTPFILE_NOCWD)
n = 0; /* CWD to entry for relative paths */
else
- n -= ftpc->file?strlen(ftpc->file):0;
+ n -= ftpc->file ? strlen(ftpc->file) : 0;
if((strlen(oldPath) == n) && !strncmp(rawPath, oldPath, n)) {
infof(data, "Request has same path as previous transfer");
}
#else
char *env = getenv(variable);
- return (env && env[0])?strdup(env):NULL;
+ return (env && env[0]) ? strdup(env) : NULL;
#endif
}
{
switch(info) {
case CURLINFO_EFFECTIVE_URL:
- *param_charp = data->state.url?data->state.url:(char *)"";
+ *param_charp = data->state.url ? data->state.url : (char *)"";
break;
case CURLINFO_EFFECTIVE_METHOD: {
const char *m = data->set.str[STRING_CUSTOMREQUEST];
*param_offt = data->progress.ul.speed;
break;
case CURLINFO_CONTENT_LENGTH_DOWNLOAD_T:
- *param_offt = (data->progress.flags & PGRS_DL_SIZE_KNOWN)?
- data->progress.dl.total_size:-1;
+ *param_offt = (data->progress.flags & PGRS_DL_SIZE_KNOWN) ?
+ data->progress.dl.total_size : -1;
break;
case CURLINFO_CONTENT_LENGTH_UPLOAD_T:
- *param_offt = (data->progress.flags & PGRS_UL_SIZE_KNOWN)?
- data->progress.ul.total_size:-1;
+ *param_offt = (data->progress.flags & PGRS_UL_SIZE_KNOWN) ?
+ data->progress.ul.total_size : -1;
break;
case CURLINFO_TOTAL_TIME_T:
*param_offt = data->progress.timespent;
*param_offt = data->id;
break;
case CURLINFO_CONN_ID:
- *param_offt = data->conn?
+ *param_offt = data->conn ?
data->conn->connection_id : data->state.recent_conn_id;
break;
default:
*param_doublep = (double)data->progress.ul.speed;
break;
case CURLINFO_CONTENT_LENGTH_DOWNLOAD:
- *param_doublep = (data->progress.flags & PGRS_DL_SIZE_KNOWN)?
- (double)data->progress.dl.total_size:-1;
+ *param_doublep = (data->progress.flags & PGRS_DL_SIZE_KNOWN) ?
+ (double)data->progress.dl.total_size : -1;
break;
case CURLINFO_CONTENT_LENGTH_UPLOAD:
- *param_doublep = (data->progress.flags & PGRS_UL_SIZE_KNOWN)?
- (double)data->progress.ul.total_size:-1;
+ *param_doublep = (data->progress.flags & PGRS_UL_SIZE_KNOWN) ?
+ (double)data->progress.ul.total_size : -1;
break;
case CURLINFO_REDIRECT_TIME:
*param_doublep = DOUBLE_SECS(data->progress.t_redirect);
impossible for applications to do == comparisons, as that would otherwise
be very tempting and then lead to the reserved bits not being reserved
anymore. */
- h->origin = (unsigned int)(hs->type | (1<<27));
+ h->origin = (unsigned int)(hs->type | (1 << 27));
h->anchor = e;
}
ipv6_works = 1;
sclose(s);
}
- return (ipv6_works>0) ? TRUE : FALSE;
+ return (ipv6_works > 0) ? TRUE : FALSE;
}
}
#endif /* USE_IPV6 */
static void hostcache_unlink_entry(void *entry)
{
struct Curl_dns_entry *dns = (struct Curl_dns_entry *) entry;
- DEBUGASSERT(dns && (dns->refcount>0));
+ DEBUGASSERT(dns && (dns->refcount > 0));
dns->refcount--;
if(dns->refcount == 0) {
{
curl_off_t bytessent = data->req.writebytecount;
curl_off_t expectsend = Curl_creader_total_length(data);
- curl_off_t upload_remain = (expectsend >= 0)? (expectsend - bytessent) : -1;
+ curl_off_t upload_remain = (expectsend >= 0) ? (expectsend - bytessent) : -1;
bool little_upload_remains = (upload_remain >= 0 && upload_remain < 2000);
bool needs_rewind = Curl_creader_needs_rewind(data);
/* By default, we would like to abort the transfer when little or unknown
if(abort_upload) {
if(upload_remain >= 0)
infof(data, "%s%sclose instead of sending %" FMT_OFF_T " more bytes",
- ongoing_auth? ongoing_auth : "",
- ongoing_auth? " send, " : "",
+ ongoing_auth ? ongoing_auth : "",
+ ongoing_auth ? " send, " : "",
upload_remain);
else
infof(data, "%s%sclose instead of sending unknown amount "
"of more bytes",
- ongoing_auth? ongoing_auth : "",
- ongoing_auth? " send, " : "");
+ ongoing_auth ? ongoing_auth : "",
+ ongoing_auth ? " send, " : "");
/* We decided to abort the ongoing transfer */
streamclose(conn, "Mid-auth HTTP and much data left to send");
/* FIXME: questionable manipulation here, can we do this differently? */
return CURLE_OK;
if(data->state.authproblem)
- return data->set.http_fail_on_error?CURLE_HTTP_RETURNED_ERROR:CURLE_OK;
+ return data->set.http_fail_on_error ? CURLE_HTTP_RETURNED_ERROR : CURLE_OK;
if((data->state.aptr.user || data->set.str[STRING_BEARER]) &&
((data->req.httpcode == 401) ||
if(is_connect)
proxy = HEADER_CONNECT;
else
- proxy = conn->bits.httpproxy && !conn->bits.tunnel_proxy?
- HEADER_PROXY:HEADER_SERVER;
+ proxy = conn->bits.httpproxy && !conn->bits.tunnel_proxy ?
+ HEADER_PROXY : HEADER_SERVER;
switch(proxy) {
case HEADER_SERVER:
if(is_connect)
proxy = HEADER_CONNECT;
else
- proxy = conn->bits.httpproxy && !conn->bits.tunnel_proxy?
- HEADER_PROXY:HEADER_SERVER;
+ proxy = conn->bits.httpproxy && !conn->bits.tunnel_proxy ?
+ HEADER_PROXY : HEADER_SERVER;
switch(proxy) {
case HEADER_SERVER:
msnprintf(datestr, sizeof(datestr),
"%s: %s, %02d %s %4d %02d:%02d:%02d GMT\r\n",
condp,
- Curl_wkday[tm->tm_wday?tm->tm_wday-1:6],
+ Curl_wkday[tm->tm_wday ? tm->tm_wday-1 : 6],
tm->tm_mday,
Curl_month[tm->tm_mon],
tm->tm_year + 1900,
(conn->remote_port == PORT_HTTP)) )
/* if(HTTPS on port 443) OR (HTTP on port 80) then do not include
the port number in the host string */
- aptr->host = aprintf("Host: %s%s%s\r\n", conn->bits.ipv6_ip?"[":"",
- host, conn->bits.ipv6_ip?"]":"");
+ aptr->host = aprintf("Host: %s%s%s\r\n", conn->bits.ipv6_ip ? "[" : "",
+ host, conn->bits.ipv6_ip ? "]" : "");
else
- aptr->host = aprintf("Host: %s%s%s:%d\r\n", conn->bits.ipv6_ip?"[":"",
- host, conn->bits.ipv6_ip?"]":"",
+ aptr->host = aprintf("Host: %s%s%s:%d\r\n",
+ conn->bits.ipv6_ip ? "[" : "",
+ host, conn->bits.ipv6_ip ? "]" : "",
conn->remote_port);
if(!aptr->host)
/* target or URL */
result = Curl_dyn_add(r, data->set.str[STRING_TARGET]?
- data->set.str[STRING_TARGET]:url);
+ data->set.str[STRING_TARGET] : url);
free(url);
if(result)
return (result);
chunked = Curl_compareheader(ptr, STRCONST("Transfer-Encoding:"),
STRCONST("chunked"));
}
- result = Curl_creader_set_fread(data, chunked? -1 : postsize);
+ result = Curl_creader_set_fread(data, chunked ? -1 : postsize);
}
return result;
linecap = TRUE;
break;
}
- result = Curl_dyn_addf(r, "%s%s=%s", count?"; ":"",
+ result = Curl_dyn_addf(r, "%s%s=%s", count ? "; " : "",
co->name, co->value);
if(result)
break;
if(!count)
result = Curl_dyn_addn(r, STRCONST("Cookie: "));
if(!result) {
- result = Curl_dyn_addf(r, "%s%s", count?"; ":"", addcookies);
+ result = Curl_dyn_addf(r, "%s%s", count ? "; " : "", addcookies);
count++;
}
}
/* TODO: not sure if we want to send this header during authentication
* negotiation, but test1084 checks for it. In which case we have a
* "null" client reader installed that gives an unexpected length. */
- curl_off_t total_len = data->req.authneg?
+ curl_off_t total_len = data->req.authneg ?
data->state.infilesize :
(data->state.resume_from + req_clen);
data->state.aptr.rangeline =
"%s",/* Alt-Used */
httpstring,
- (data->state.aptr.host?data->state.aptr.host:""),
+ (data->state.aptr.host ? data->state.aptr.host : ""),
#ifndef CURL_DISABLE_PROXY
- data->state.aptr.proxyuserpwd?
- data->state.aptr.proxyuserpwd:"",
+ data->state.aptr.proxyuserpwd ?
+ data->state.aptr.proxyuserpwd : "",
#else
"",
#endif
- data->state.aptr.userpwd?data->state.aptr.userpwd:"",
- (data->state.use_range && data->state.aptr.rangeline)?
- data->state.aptr.rangeline:"",
+ data->state.aptr.userpwd ? data->state.aptr.userpwd : "",
+ (data->state.use_range && data->state.aptr.rangeline) ?
+ data->state.aptr.rangeline : "",
(data->set.str[STRING_USERAGENT] &&
*data->set.str[STRING_USERAGENT] &&
- data->state.aptr.uagent)?
- data->state.aptr.uagent:"",
- p_accept?p_accept:"",
- data->state.aptr.te?data->state.aptr.te:"",
+ data->state.aptr.uagent) ?
+ data->state.aptr.uagent : "",
+ p_accept ? p_accept : "",
+ data->state.aptr.te ? data->state.aptr.te : "",
(data->set.str[STRING_ENCODING] &&
*data->set.str[STRING_ENCODING] &&
- data->state.aptr.accept_encoding)?
- data->state.aptr.accept_encoding:"",
- (data->state.referer && data->state.aptr.ref)?
- data->state.aptr.ref:"" /* Referer: <data> */,
+ data->state.aptr.accept_encoding) ?
+ data->state.aptr.accept_encoding : "",
+ (data->state.referer && data->state.aptr.ref) ?
+ data->state.aptr.ref : "" /* Referer: <data> */,
#ifndef CURL_DISABLE_PROXY
(conn->bits.httpproxy &&
!conn->bits.tunnel_proxy &&
!Curl_checkheaders(data, STRCONST("Proxy-Connection")) &&
- !Curl_checkProxyheaders(data,
- conn,
- STRCONST("Proxy-Connection")))?
+ !Curl_checkProxyheaders(data, conn,
+ STRCONST("Proxy-Connection"))) ?
"Proxy-Connection: Keep-Alive\r\n":"",
#else
"",
{
struct curl_slist *head = data->set.http200aliases;
statusline rc = STATUS_BAD;
- statusline onmatch = len >= 5? STATUS_DONE : STATUS_UNKNOWN;
+ statusline onmatch = len >= 5 ? STATUS_DONE : STATUS_UNKNOWN;
while(head) {
if(checkprefixmax(head->data, s, len)) {
const char *s, size_t len)
{
statusline result = STATUS_BAD;
- statusline onmatch = len >= 5? STATUS_DONE : STATUS_UNKNOWN;
+ statusline onmatch = len >= 5 ? STATUS_DONE : STATUS_UNKNOWN;
(void)data; /* unused */
if(checkprefixmax("RTSP/", s, len))
result = onmatch;
#else
0
#endif
- ))? HD_VAL(hd, hdlen, "Alt-Svc:") : NULL;
+ )) ? HD_VAL(hd, hdlen, "Alt-Svc:") : NULL;
if(v) {
/* the ALPN of the current request */
- enum alpnid id = (conn->httpversion == 30)? ALPN_h3 :
+ enum alpnid id = (conn->httpversion == 30) ? ALPN_h3 :
(conn->httpversion == 20) ? ALPN_h2 : ALPN_h1;
return Curl_altsvc_parse(data, data->asi, v, id, conn->host.name,
curlx_uitous((unsigned int)conn->remote_port));
case 'c':
case 'C':
/* Check for Content-Length: header lines to get size */
- v = (!k->http_bodyless && !data->set.ignorecl)?
- HD_VAL(hd, hdlen, "Content-Length:") : NULL;
+ v = (!k->http_bodyless && !data->set.ignorecl) ?
+ HD_VAL(hd, hdlen, "Content-Length:") : NULL;
if(v) {
curl_off_t contentlength;
CURLofft offt = curlx_strtoofft(v, NULL, 10, &contentlength);
}
return CURLE_OK;
}
- v = (!k->http_bodyless && data->set.str[STRING_ENCODING])?
- HD_VAL(hd, hdlen, "Content-Encoding:") : NULL;
+ v = (!k->http_bodyless && data->set.str[STRING_ENCODING]) ?
+ HD_VAL(hd, hdlen, "Content-Encoding:") : NULL;
if(v) {
/*
* Process Content-Encoding. Look for the values: identity,
infof(data, "HTTP/1.0 connection set to keep alive");
return CURLE_OK;
}
- v = !k->http_bodyless? HD_VAL(hd, hdlen, "Content-Range:") : NULL;
+ v = !k->http_bodyless ? HD_VAL(hd, hdlen, "Content-Range:") : NULL;
if(v) {
/* Content-Range: bytes [num]-
Content-Range: bytes: [num]-
case 'l':
case 'L':
v = (!k->http_bodyless &&
- (data->set.timecondition || data->set.get_filetime))?
+ (data->set.timecondition || data->set.get_filetime)) ?
HD_VAL(hd, hdlen, "Last-Modified:") : NULL;
if(v) {
k->timeofdoc = Curl_getdate_capped(v);
case 's':
case 'S':
#if !defined(CURL_DISABLE_COOKIES)
- v = (data->cookies && data->state.cookie_engine)?
+ v = (data->cookies && data->state.cookie_engine) ?
HD_VAL(hd, hdlen, "Set-Cookie:") : NULL;
if(v) {
/* If there is a custom-set Host: name, use it here, or else use
* real peer hostname. */
- const char *host = data->state.aptr.cookiehost?
- data->state.aptr.cookiehost:conn->host.name;
+ const char *host = data->state.aptr.cookiehost ?
+ data->state.aptr.cookiehost : conn->host.name;
const bool secure_context =
conn->handler->protocol&(CURLPROTO_HTTPS|CURLPROTO_WSS) ||
strcasecompare("localhost", host) ||
0
#endif
)
- )? HD_VAL(hd, hdlen, "Strict-Transport-Security:") : NULL;
+ ) ? HD_VAL(hd, hdlen, "Strict-Transport-Security:") : NULL;
if(v) {
CURLcode check =
Curl_hsts_parse(data->hsts, conn->host.name, v);
*/
v = (!k->http_bodyless &&
(data->state.httpreq != HTTPREQ_HEAD) &&
- (k->httpcode != 304))?
- HD_VAL(hd, hdlen, "Transfer-Encoding:") : NULL;
+ (k->httpcode != 304)) ?
+ HD_VAL(hd, hdlen, "Transfer-Encoding:") : NULL;
if(v) {
/* One or more encodings. We check for chunked and/or a compression
algorithm. */
return result;
data->req.deductheadercount = (100 <= data->req.httpcode &&
- 199 >= data->req.httpcode)?
- data->req.headerbytecount:0;
+ 199 >= data->req.httpcode) ?
+ data->req.headerbytecount : 0;
return result;
}
}
result = CURLE_OK;
out:
- *pstatus = result? -1 : status;
+ *pstatus = result ? -1 : status;
return result;
}
infof(data, "set pseudo header %s to %s", HTTP_PSEUDO_SCHEME, scheme);
}
else {
- scheme = (data->conn && data->conn->handler->flags & PROTOPT_SSL)?
- "https" : "http";
+ scheme = (data->conn && data->conn->handler->flags & PROTOPT_SSL) ?
+ "https" : "http";
}
}
struct Curl_creader *reader, int premature)
{
struct cr_exp100_ctx *ctx = reader->ctx;
- ctx->state = premature? EXP100_FAILED : EXP100_SEND_DATA;
+ ctx->state = premature ? EXP100_FAILED : EXP100_SEND_DATA;
data->req.keepon &= ~KEEP_SEND_TIMED;
Curl_expire_done(data, EXPIRE_100_TIMEOUT);
}
else if(*err == CURLE_AGAIN) {
/* no line end in `buf`, add it to our scratch */
*err = Curl_dyn_addn(&parser->scratch, (const unsigned char *)buf, buflen);
- nread = (*err)? -1 : (ssize_t)buflen;
+ nread = (*err) ? -1 : (ssize_t)buflen;
}
return nread;
}
result = Curl_dyn_addf(dbuf, "%s %s%s%s%s HTTP/1.%d\r\n",
req->method,
- req->scheme? req->scheme : "",
- req->scheme? "://" : "",
- req->authority? req->authority : "",
- req->path? req->path : "",
+ req->scheme ? req->scheme : "",
+ req->scheme ? "://" : "",
+ req->authority ? req->authority : "",
+ req->path ? req->path : "",
http_minor);
if(result)
goto out;
static void free_push_headers(struct h2_stream_ctx *stream)
{
size_t i;
- for(i = 0; i<stream->push_headers_used; i++)
+ for(i = 0; i < stream->push_headers_used; i++)
free(stream->push_headers[i]);
Curl_safefree(stream->push_headers);
stream->push_headers_used = 0;
int32_t dwsize;
int rv;
- dwsize = paused? 0 : cf_h2_get_desired_local_win(cf, data);
+ dwsize = paused ? 0 : cf_h2_get_desired_local_win(cf, data);
if(dwsize != stream->local_window_size) {
int32_t wsize = nghttp2_session_get_stream_effective_local_window_size(
ctx->h2, stream->id);
/* all set, traffic will be send on connect */
result = CURLE_OK;
CURL_TRC_CF(data, cf, "[0] created h2 session%s",
- ctx->via_h1_upgrade? " (via h1 upgrade)" : "");
+ ctx->via_h1_upgrade ? " (via h1 upgrade)" : "");
out:
if(cbs)
}
return result;
}
- return Curl_bufq_is_empty(&ctx->outbufq)? CURLE_OK: CURLE_AGAIN;
+ return Curl_bufq_is_empty(&ctx->outbufq) ? CURLE_OK : CURLE_AGAIN;
}
/*
return NULL;
len = strlen(header);
- for(i = 0; i<stream->push_headers_used; i++) {
+ for(i = 0; i < stream->push_headers_used; i++) {
if(!strncmp(header, stream->push_headers[i], len)) {
/* sub-match, make sure that it is followed by a colon */
if(stream->push_headers[i][len] != ':')
case NGHTTP2_GOAWAY: {
char scratch[128];
size_t s_len = sizeof(scratch)/sizeof(scratch[0]);
- size_t len = (frame->goaway.opaque_data_len < s_len)?
- frame->goaway.opaque_data_len : s_len-1;
- if(len)
- memcpy(scratch, frame->goaway.opaque_data, len);
- scratch[len] = '\0';
- return msnprintf(buffer, blen, "FRAME[GOAWAY, error=%d, reason='%s', "
- "last_stream=%d]", frame->goaway.error_code,
- scratch, frame->goaway.last_stream_id);
+ size_t len = (frame->goaway.opaque_data_len < s_len) ?
+ frame->goaway.opaque_data_len : s_len-1;
+ if(len)
+ memcpy(scratch, frame->goaway.opaque_data, len);
+ scratch[len] = '\0';
+ return msnprintf(buffer, blen, "FRAME[GOAWAY, error=%d, reason='%s', "
+ "last_stream=%d]", frame->goaway.error_code,
+ scratch, frame->goaway.last_stream_id);
}
case NGHTTP2_WINDOW_UPDATE: {
return msnprintf(buffer, blen,
return 0;
}
- return on_stream_frame(cf, data_s, frame)? NGHTTP2_ERR_CALLBACK_FAILURE : 0;
+ return on_stream_frame(cf, data_s, frame) ? NGHTTP2_ERR_CALLBACK_FAILURE : 0;
}
static int on_data_chunk_recv(nghttp2_session *session, uint8_t flags,
DEBUGASSERT(call_data);
/* stream id 0 is the connection, do not look there for streams. */
- data_s = stream_id?
- nghttp2_session_get_stream_user_data(session, stream_id) : NULL;
+ data_s = stream_id ?
+ nghttp2_session_get_stream_user_data(session, stream_id) : NULL;
if(!data_s) {
CURL_TRC_CF(call_data, cf,
"[%d] on_stream_close, no easy set on stream", stream_id);
*data_flags = NGHTTP2_DATA_FLAG_EOF;
return nread;
}
- return (nread == 0)? NGHTTP2_ERR_DEFERRED : nread;
+ return (nread == 0) ? NGHTTP2_ERR_DEFERRED : nread;
}
#if !defined(CURL_DISABLE_VERBOSE_STRINGS)
}
else if(stream->reset) {
failf(data, "HTTP/2 stream %u was reset", stream->id);
- *err = data->req.bytecount? CURLE_PARTIAL_FILE : CURLE_HTTP2;
+ *err = data->req.bytecount ? CURLE_PARTIAL_FILE : CURLE_HTTP2;
return -1;
}
static int sweight_wanted(const struct Curl_easy *data)
{
/* 0 weight is not set by user and we take the nghttp2 default one */
- return data->set.priority.weight?
+ return data->set.priority.weight ?
data->set.priority.weight : NGHTTP2_DEFAULT_WEIGHT;
}
static int sweight_in_effect(const struct Curl_easy *data)
{
/* 0 weight is not set by user and we take the nghttp2 default one */
- return data->state.priority.weight?
+ return data->state.priority.weight ?
data->state.priority.weight : NGHTTP2_DEFAULT_WEIGHT;
}
{
struct Curl_data_priority *prio = &data->set.priority;
struct h2_stream_ctx *depstream = H2_STREAM_CTX(ctx, prio->parent);
- int32_t depstream_id = depstream? depstream->id:0;
+ int32_t depstream_id = depstream ? depstream->id : 0;
nghttp2_priority_spec_init(pri_spec, depstream_id,
sweight_wanted(data),
data->set.priority.exclusive);
(ctx->conn_closed && Curl_bufq_is_empty(&ctx->inbufq)) ||
(ctx->rcvd_goaway && ctx->remote_max_sid < stream->id)) {
CURL_TRC_CF(data, cf, "[%d] returning ERR", stream->id);
- *err = data->req.bytecount? CURLE_PARTIAL_FILE : CURLE_HTTP2;
+ *err = data->req.bytecount ? CURLE_PARTIAL_FILE : CURLE_HTTP2;
nread = -1;
}
}
else {
CURL_TRC_CF(data, cf, "[0] ingress: read %zd bytes", nread);
- data_max_bytes = (data_max_bytes > (size_t)nread)?
- (data_max_bytes - (size_t)nread) : 0;
+ data_max_bytes = (data_max_bytes > (size_t)nread) ?
+ (data_max_bytes - (size_t)nread) : 0;
}
if(h2_process_pending_input(cf, data, &result))
out:
CURL_TRC_CF(data, cf, "[%d] submit -> %zd, %d",
- stream? stream->id : -1, nwritten, *err);
+ stream ? stream->id : -1, nwritten, *err);
Curl_safefree(nva);
*pstream = stream;
Curl_dynhds_free(&h2_headers);
Curl_expire(data, 0, EXPIRE_RUN_NOW);
}
CURL_TRC_CF(data, cf, "[%d] stream now %spaused", stream->id,
- pause? "" : "un");
+ pause ? "" : "un");
}
return CURLE_OK;
}
if(ctx && (!Curl_bufq_is_empty(&ctx->inbufq)
|| (stream && !Curl_bufq_is_empty(&stream->sendbuf))))
return TRUE;
- return cf->next? cf->next->cft->has_data_pending(cf->next, data) : FALSE;
+ return cf->next ? cf->next->cft->has_data_pending(cf->next, data) : FALSE;
}
static bool cf_h2_is_alive(struct Curl_cfilter *cf,
else {
effective_max = ctx->max_concurrent_streams;
}
- *pres1 = (effective_max > INT_MAX)? INT_MAX : (int)effective_max;
+ *pres1 = (effective_max > INT_MAX) ? INT_MAX : (int)effective_max;
CF_DATA_RESTORE(cf, save);
return CURLE_OK;
case CF_QUERY_STREAM_ERROR: {
struct h2_stream_ctx *stream = H2_STREAM_CTX(ctx, data);
- *pres1 = stream? (int)stream->error : 0;
+ *pres1 = stream ? (int)stream->error : 0;
return CURLE_OK;
}
case CF_QUERY_NEED_FLUSH: {
default:
break;
}
- return cf->next?
+ return cf->next ?
cf->next->cft->query(cf->next, data, query, pres1, pres2) :
CURLE_UNKNOWN_OPTION;
}
const struct connectdata *conn,
int sockindex)
{
- return conn? Curl_cf_is_http2(conn->cfilter[sockindex], data) : FALSE;
+ return conn ? Curl_cf_is_http2(conn->cfilter[sockindex], data) : FALSE;
}
bool Curl_http2_may_switch(struct Curl_easy *data,
}
}
/* URL encode */
- out[1] = hex[((unsigned char)*q)>>4];
+ out[1] = hex[((unsigned char)*q) >> 4];
out[2] = hex[*q & 0xf];
result = Curl_dyn_addn(dq, out, 3);
break;
if(result)
goto out;
- authority = aprintf("%s%s%s:%d", ipv6_ip?"[":"", hostname,
- ipv6_ip?"]":"", port);
+ authority = aprintf("%s%s%s:%d", ipv6_ip ? "[" : "", hostname,
+ ipv6_ip ?"]" : "", port);
if(!authority) {
result = CURLE_OUT_OF_MEMORY;
goto out;
*done = FALSE;
if(!ctx->cf_protocol) {
struct Curl_cfilter *cf_protocol = NULL;
- int alpn = Curl_conn_cf_is_ssl(cf->next)?
+ int alpn = Curl_conn_cf_is_ssl(cf->next) ?
cf->conn->proxy_alpn : CURL_HTTP_VERSION_1_1;
/* First time call after the subchain connected */
case CURL_HTTP_VERSION_1_1:
CURL_TRC_CF(data, cf, "installing subfilter for HTTP/1.1");
infof(data, "CONNECT tunnel: HTTP/1.%d negotiated",
- (alpn == CURL_HTTP_VERSION_1_0)? 0 : 1);
+ (alpn == CURL_HTTP_VERSION_1_0) ? 0 : 1);
result = Curl_cf_h1_proxy_insert_after(cf, data);
if(result)
goto out;
}
else {
/* if 'e' is NULL here, we insert the new element first in the list */
- ne->_next = e?e->_next:list->_head;
+ ne->_next = e ? e->_next : list->_head;
ne->_prev = e;
if(!e) {
list->_head->_prev = ne;
s2 = strrchr(path, '\\');
if(s1 && s2) {
- path = (s1 > s2? s1 : s2) + 1;
+ path = (s1 > s2 ? s1 : s2) + 1;
}
else if(s1)
path = s1 + 1;
for(cursize = 0; cursize < size; cursize++) {
*buffer = st->buf[st->bufbeg];
if(*buffer++ & 0x80)
- return cursize? cursize: READ_ERROR;
+ return cursize ? cursize : READ_ERROR;
st->bufbeg++;
}
if(n >= st->bufend && ateof)
return 1;
if(n + 2 > st->bufend)
- return ateof? 0: -1;
+ return ateof ? 0 : -1;
if(qp_class[st->buf[n] & 0xFF] == QP_CR &&
qp_class[st->buf[n + 1] & 0xFF] == QP_LF)
return 1;
{
/* Determining the size can only be done by reading the data: unless the
data size is 0, we return it as unknown (-1). */
- return part->datasize? -1: 0;
+ return part->datasize ? -1 : 0;
}
if(part->fp)
return 0;
part->fp = fopen_read(part->data, "rb");
- return part->fp? 0: -1;
+ return part->fp ? 0 : -1;
}
static size_t mime_file_read(char *buffer, size_t size, size_t nitems,
if(mime_open_file(part))
return CURL_SEEKFUNC_FAIL;
- return fseek(part->fp, (long) offset, whence)?
- CURL_SEEKFUNC_CANTSEEK: CURL_SEEKFUNC_OK;
+ return fseek(part->fp, (long) offset, whence) ?
+ CURL_SEEKFUNC_CANTSEEK : CURL_SEEKFUNC_OK;
}
static void mime_file_free(void *ptr)
break;
case READ_ERROR:
case STOP_FILLING:
- return cursize? cursize: sz;
+ return cursize ? cursize : sz;
default:
cursize += sz;
buffer += sz;
st->bufend = len;
}
if(st->bufend >= sizeof(st->buf))
- return cursize? cursize: READ_ERROR; /* Buffer full. */
+ return cursize ? cursize : READ_ERROR; /* Buffer full. */
sz = read_part_content(part, st->buf + st->bufend,
sizeof(st->buf) - st->bufend, hasread);
switch(sz) {
case CURL_READFUNC_PAUSE:
case READ_ERROR:
case STOP_FILLING:
- return cursize? cursize: sz;
+ return cursize ? cursize : sz;
default:
st->bufend += sz;
break;
switch(part->state.state) {
case MIMESTATE_BEGIN:
mimesetstate(&part->state,
- (part->flags & MIME_BODY_ONLY)?
- MIMESTATE_BODY: MIMESTATE_CURLHEADERS,
+ (part->flags & MIME_BODY_ONLY) ?
+ MIMESTATE_BODY : MIMESTATE_CURLHEADERS,
part->curlheaders);
break;
case MIMESTATE_USERHEADERS:
case CURL_READFUNC_PAUSE:
case READ_ERROR:
case STOP_FILLING:
- return cursize? cursize: sz;
+ return cursize ? cursize : sz;
}
break;
case MIMESTATE_END:
case CURL_READFUNC_PAUSE:
case READ_ERROR:
case STOP_FILLING:
- return cursize? cursize: sz;
+ return cursize ? cursize : sz;
case 0:
mimesetstate(&mime->state, MIMESTATE_BOUNDARY1, part->nextpart);
break;
/* No one knows about the cloned subparts, thus always attach ownership
to the part. */
mime = curl_mime_init(data);
- res = mime? curl_mime_subparts(dst, mime): CURLE_OUT_OF_MEMORY;
+ res = mime ? curl_mime_subparts(dst, mime) : CURLE_OUT_OF_MEMORY;
/* Duplicate subparts. */
for(s = ((curl_mime *) src->arg)->firstpart; !res && s; s = s->nextpart) {
d = curl_mime_addpart(mime);
- res = d? Curl_mime_duppart(data, d, s): CURLE_OUT_OF_MEMORY;
+ res = d ? Curl_mime_duppart(data, d, s) : CURLE_OUT_OF_MEMORY;
}
break;
default: /* Invalid kind: should not occur. */
subparts->parent = part;
/* Subparts are processed internally: no read callback. */
part->seekfunc = mime_subparts_seek;
- part->freefunc = take_ownership? mime_subparts_free: mime_subparts_unbind;
+ part->freefunc = take_ownership ? mime_subparts_free :
+ mime_subparts_unbind;
part->arg = subparts;
part->datasize = -1;
part->kind = MIMEKIND_MULTIPART;
/* Rewind mime stream. */
static CURLcode mime_rewind(curl_mimepart *part)
{
- return mime_part_rewind(part) == CURL_SEEKFUNC_OK?
- CURLE_OK: CURLE_SEND_FAIL_REWIND;
+ return mime_part_rewind(part) == CURL_SEEKFUNC_OK ?
+ CURLE_OK : CURLE_SEND_FAIL_REWIND;
}
/* Compute header list size. */
free(s);
}
- return hdr? CURLE_OK: CURLE_OUT_OF_MEMORY;
+ return hdr ? CURLE_OK : CURLE_OUT_OF_MEMORY;
}
/* Add a content type header. */
const char *type, const char *boundary)
{
return Curl_mime_add_header(slp, "Content-Type: %s%s%s", type,
- boundary? "; boundary=": "",
- boundary? boundary: "");
+ boundary ? "; boundary=" : "",
+ boundary ? boundary : "");
}
const char *Curl_mime_contenttype(const char *filename)
ret = Curl_mime_add_header(&part->curlheaders,
"Content-Disposition: %s%s%s%s%s%s%s",
disposition,
- name? "; name=\"": "",
- name? name: "",
- name? "\"": "",
- filename? "; filename=\"": "",
- filename? filename: "",
- filename? "\"": "");
+ name ? "; name=\"" : "",
+ name ? name : "",
+ name ? "\"" : "",
+ filename ? "; filename=\"" : "",
+ filename ? filename : "",
+ filename ? "\"" : "");
Curl_safefree(name);
Curl_safefree(filename);
if(ret)
/* conversion and display flags */
enum {
- FLAGS_SPACE = 1<<0,
- FLAGS_SHOWSIGN = 1<<1,
- FLAGS_LEFT = 1<<2,
- FLAGS_ALT = 1<<3,
- FLAGS_SHORT = 1<<4,
- FLAGS_LONG = 1<<5,
- FLAGS_LONGLONG = 1<<6,
- FLAGS_LONGDOUBLE = 1<<7,
- FLAGS_PAD_NIL = 1<<8,
- FLAGS_UNSIGNED = 1<<9,
- FLAGS_OCTAL = 1<<10,
- FLAGS_HEX = 1<<11,
- FLAGS_UPPER = 1<<12,
- FLAGS_WIDTH = 1<<13, /* '*' or '*<num>$' used */
- FLAGS_WIDTHPARAM = 1<<14, /* width PARAMETER was specified */
- FLAGS_PREC = 1<<15, /* precision was specified */
- FLAGS_PRECPARAM = 1<<16, /* precision PARAMETER was specified */
- FLAGS_CHAR = 1<<17, /* %c story */
- FLAGS_FLOATE = 1<<18, /* %e or %E */
- FLAGS_FLOATG = 1<<19, /* %g or %G */
- FLAGS_SUBSTR = 1<<20 /* no input, only substring */
+ FLAGS_SPACE = 1 << 0,
+ FLAGS_SHOWSIGN = 1 << 1,
+ FLAGS_LEFT = 1 << 2,
+ FLAGS_ALT = 1 << 3,
+ FLAGS_SHORT = 1 << 4,
+ FLAGS_LONG = 1 << 5,
+ FLAGS_LONGLONG = 1 << 6,
+ FLAGS_LONGDOUBLE = 1 << 7,
+ FLAGS_PAD_NIL = 1 << 8,
+ FLAGS_UNSIGNED = 1 << 9,
+ FLAGS_OCTAL = 1 << 10,
+ FLAGS_HEX = 1 << 11,
+ FLAGS_UPPER = 1 << 12,
+ FLAGS_WIDTH = 1 << 13, /* '*' or '*<num>$' used */
+ FLAGS_WIDTHPARAM = 1 << 14, /* width PARAMETER was specified */
+ FLAGS_PREC = 1 << 15, /* precision was specified */
+ FLAGS_PRECPARAM = 1 << 16, /* precision PARAMETER was specified */
+ FLAGS_CHAR = 1 << 17, /* %c story */
+ FLAGS_FLOATE = 1 << 18, /* %e or %E */
+ FLAGS_FLOATG = 1 << 19, /* %g or %G */
+ FLAGS_SUBSTR = 1 << 20 /* no input, only substring */
};
enum {
}
else if(flags & FLAGS_HEX) {
/* Hexadecimal unsigned integer */
- digits = (flags & FLAGS_UPPER)? upper_digits : lower_digits;
+ digits = (flags & FLAGS_UPPER) ? upper_digits : lower_digits;
base = 16;
is_neg = FALSE;
}
if(iptr->val.ptr) {
/* If the pointer is not NULL, write it as a %#x spec. */
base = 16;
- digits = (flags & FLAGS_UPPER)? upper_digits : lower_digits;
+ digits = (flags & FLAGS_UPPER) ? upper_digits : lower_digits;
is_alt = TRUE;
num = (size_t) iptr->val.ptr;
is_neg = FALSE;
{
int i;
- for(i = 0; (len > 0) && (i<4); i++) {
+ for(i = 0; (len > 0) && (i < 4); i++) {
unsigned char encoded;
encoded = len % 0x80;
len /= 0x80;
return CURLE_OUT_OF_MEMORY;
rlen = Curl_dyn_len(&mq->recvbuf);
}
- return (rlen >= nbytes)? CURLE_OK : CURLE_AGAIN;
+ return (rlen >= nbytes) ? CURLE_OK : CURLE_AGAIN;
}
static void mqtt_recv_consume(struct Curl_easy *data, size_t nbytes)
infof(data, "%s (from %s) (next is %s)",
statenames[state],
statenames[mqtt->state],
- (state == MQTT_FIRST)? statenames[nextstate] : "");
+ (state == MQTT_FIRST) ? statenames[nextstate] : "");
#endif
mqtt->state = state;
if(state == MQTT_FIRST)
if(!result) {
if(dophase_done) {
/* after DO, go DO_DONE or DO_MORE */
- multistate(data, data->conn->bits.do_more?
+ multistate(data, data->conn->bits.do_more ?
MSTATE_DOING_MORE : MSTATE_DID);
rc = CURLM_CALL_MULTI_PERFORM;
} /* dophase_done */
if(control) {
/* if positive, advance to DO_DONE
if negative, go back to DOING */
- multistate(data, control == 1?
+ multistate(data, control == 1 ?
MSTATE_DID : MSTATE_DOING);
rc = CURLM_CALL_MULTI_PERFORM;
}
streamclose(data->conn, "Aborted by callback");
/* if not yet in DONE state, go there, otherwise COMPLETED */
- multistate(data, (data->mstate < MSTATE_DONE)?
- MSTATE_DONE: MSTATE_COMPLETED);
+ multistate(data, (data->mstate < MSTATE_DONE) ?
+ MSTATE_DONE : MSTATE_COMPLETED);
rc = CURLM_CALL_MULTI_PERFORM;
}
}
if(entry) {
/* check if new for this transfer */
unsigned int j;
- for(j = 0; j< last_ps->num; j++) {
+ for(j = 0; j < last_ps->num; j++) {
if(s == last_ps->sockets[j]) {
last_action = last_ps->actions[j];
break;
multi->timetree = Curl_splay(tv_zero, multi->timetree);
/* this will not return NULL from a non-emtpy tree, but some compilers
* are not convinced of that. Analyzers are hard. */
- *expire_time = multi->timetree? multi->timetree->key : tv_zero;
+ *expire_time = multi->timetree ? multi->timetree->key : tv_zero;
/* 'multi->timetree' will be non-NULL here but the compilers sometimes
yell at us if we assume so */
if(rc != LDAP_URL_SUCCESS) {
const char *msg = "url parsing problem";
- result = rc == LDAP_URL_ERR_MEM? CURLE_OUT_OF_MEMORY: CURLE_URL_MALFORMAT;
+ result = rc == LDAP_URL_ERR_MEM ? CURLE_OUT_OF_MEMORY :
+ CURLE_URL_MALFORMAT;
rc -= LDAP_URL_SUCCESS;
if((size_t) rc < sizeof(url_errs) / sizeof(url_errs[0]))
msg = url_errs[rc];
ptr++;
}
- return result == CURLE_URL_MALFORMAT? CURLE_SETOPT_OPTION_SYNTAX: result;
+ return result == CURLE_URL_MALFORMAT ? CURLE_SETOPT_OPTION_SYNTAX : result;
}
static CURLcode oldap_setup_connection(struct Curl_easy *data,
oldap_state(data, newstate);
else
result = oldap_map_error(rc,
- data->state.aptr.user?
- CURLE_LOGIN_DENIED: CURLE_LDAP_CANNOT_BIND);
+ data->state.aptr.user ?
+ CURLE_LOGIN_DENIED : CURLE_LDAP_CANNOT_BIND);
return result;
}
hosturl = aprintf("%s://%s%s%s:%d",
conn->handler->scheme,
- conn->bits.ipv6_ip? "[": "",
+ conn->bits.ipv6_ip ? "[" : "",
conn->host.name,
- conn->bits.ipv6_ip? "]": "",
+ conn->bits.ipv6_ip ? "]" : "",
conn->remote_port);
if(!hosturl)
return CURLE_OUT_OF_MEMORY;
ldap_msgfree(msg);
*err = result;
- return result? -1: 0;
+ return result ? -1 : 0;
}
#ifdef USE_SSL
what = &Curl_wkday[0];
else
return -1; /* too short */
- for(i = 0; i<7; i++) {
+ for(i = 0; i < 7; i++) {
size_t ilen = strlen(what[0]);
if((ilen == len) &&
strncasecompare(check, what[0], len))
if(len != 3)
return -1; /* not a month */
- for(i = 0; i<12; i++) {
+ for(i = 0; i < 12; i++) {
if(strncasecompare(check, what[0], 3))
return i;
what++;
if(len > 4) /* longer than any valid timezone */
return -1;
- for(i = 0; i< sizeof(tz)/sizeof(tz[0]); i++) {
+ for(i = 0; i < sizeof(tz)/sizeof(tz[0]); i++) {
size_t ilen = strlen(what->name);
if((ilen == len) &&
strncasecompare(check, what->name, len))
if((tzoff == -1) &&
((end - date) == 4) &&
(val <= 1400) &&
- (indate< date) &&
+ (indate < date) &&
((date[-1] == '+' || date[-1] == '-'))) {
/* four digits and a value less than or equal to 1400 (to take into
account all sorts of funny time zone diffs) and it is preceded
/* the + and - prefix indicates the local time compared to GMT,
this we need their reversed math to get what we want */
- tzoff = date[-1]=='+'?-tzoff:tzoff;
+ tzoff = date[-1]=='+' ? -tzoff : tzoff;
}
if(((end - date) == 8) &&
}
if(!found && (dignext == DATE_MDAY) && (mdaynum == -1)) {
- if((val > 0) && (val<32)) {
+ if((val > 0) && (val < 32)) {
mdaynum = val;
found = TRUE;
}
{
struct connectdata *conn = data->conn;
timediff_t timeout_ms; /* in milliseconds */
- timediff_t response_time = (data->set.server_response_timeout)?
- data->set.server_response_timeout: pp->response_time;
+ timediff_t response_time = (data->set.server_response_timeout) ?
+ data->set.server_response_timeout : pp->response_time;
/* if CURLOPT_SERVER_RESPONSE_TIMEOUT is set, use that to determine
remaining time, or use pp->response because SERVER_RESPONSE_TIMEOUT is
array. With N_ENTRIES filled in, we have about N_ENTRIES-1 seconds of
transfer. Imagine, after one second we have filled in two entries,
after two seconds we have filled in three entries etc. */
- countindex = ((p->speeder_c >= CURR_TIME)? CURR_TIME:p->speeder_c) - 1;
+ countindex = ((p->speeder_c >= CURR_TIME) ? CURR_TIME : p->speeder_c) - 1;
/* first of all, we do not do this if there is no counted seconds yet */
if(countindex) {
/* Get the index position to compare with the 'nowindex' position.
Get the oldest entry possible. While we have less than CURR_TIME
entries, the first entry will remain the oldest. */
- checkindex = (p->speeder_c >= CURR_TIME)? p->speeder_c%CURR_TIME:0;
+ checkindex = (p->speeder_c >= CURR_TIME) ? p->speeder_c%CURR_TIME : 0;
/* Figure out the exact time for the time span */
span_ms = Curl_timediff(now, p->speeder_time[checkindex]);
/* Since both happen at the same time, total expected duration is max. */
total_estm.secs = CURLMAX(ul_estm.secs, dl_estm.secs);
/* create the three time strings */
- time2str(time_left, total_estm.secs > 0?(total_estm.secs - cur_secs):0);
+ time2str(time_left, total_estm.secs > 0 ? (total_estm.secs - cur_secs) : 0);
time2str(time_total, total_estm.secs);
time2str(time_spent, cur_secs);
/* Get the total amount of data expected to get transferred */
total_expected_size =
- ((p->flags & PGRS_UL_SIZE_KNOWN)? p->ul.total_size:p->ul.cur_size) +
- ((p->flags & PGRS_DL_SIZE_KNOWN)? p->dl.total_size:p->dl.cur_size);
+ ((p->flags & PGRS_UL_SIZE_KNOWN) ? p->ul.total_size : p->ul.cur_size) +
+ ((p->flags & PGRS_DL_SIZE_KNOWN) ? p->dl.total_size : p->dl.cur_size);
/* We have transferred this much so far */
total_cur_size = p->dl.cur_size + p->ul.cur_size;
psl = psl_latest(NULL);
dynamic = psl != NULL;
/* Take care of possible time computation overflow. */
- expires = now < TIME_T_MAX - PSL_TTL? now + PSL_TTL: TIME_T_MAX;
+ expires = now < TIME_T_MAX - PSL_TTL ? now + PSL_TTL : TIME_T_MAX;
/* Only get the built-in PSL if we do not already have the "latest". */
if(!psl && !pslcache->dynamic)
data->req.writebytecount);
else if(!data->req.download_done) {
DEBUGASSERT(Curl_bufq_is_empty(&data->req.sendbuf));
- infof(data, Curl_creader_total_length(data)?
- "We are completely uploaded and fine" :
- "Request completely sent off");
+ infof(data, Curl_creader_total_length(data) ?
+ "We are completely uploaded and fine" :
+ "Request completely sent off");
}
return Curl_xfer_send_close(data);
/* Accept Headers for DESCRIBE requests */
if(rtspreq == RTSPREQ_DESCRIBE) {
/* Accept Header */
- p_accept = Curl_checkheaders(data, STRCONST("Accept"))?
- NULL:"Accept: application/sdp\r\n";
+ p_accept = Curl_checkheaders(data, STRCONST("Accept")) ?
+ NULL : "Accept: application/sdp\r\n";
/* Accept-Encoding header */
if(!Curl_checkheaders(data, STRCONST("Accept-Encoding")) &&
in_body = (data->req.headerline && !rtspc->in_header) &&
(data->req.size >= 0) &&
(data->req.bytecount < data->req.size);
- body_remain = in_body? (data->req.size - data->req.bytecount) : 0;
+ body_remain = in_body ? (data->req.size - data->req.bytecount) : 0;
DEBUGASSERT(body_remain >= 0);
if(body_remain) {
if((curl_off_t)blen > body_remain)
data->req.size));
if(!result && (is_eos || blen)) {
result = Curl_client_write(data, CLIENTWRITE_BODY|
- (is_eos? CLIENTWRITE_EOS:0),
+ (is_eos ? CLIENTWRITE_EOS : 0),
(char *)buf, blen);
}
curl_off_t Curl_creader_def_total_length(struct Curl_easy *data,
struct Curl_creader *reader)
{
- return reader->next?
+ return reader->next ?
reader->next->crt->total_length(data, reader->next) : -1;
}
curl_off_t Curl_creader_total_length(struct Curl_easy *data)
{
struct Curl_creader *r = data->req.reader_stack;
- return r? r->crt->total_length(data, r) : -1;
+ return r ? r->crt->total_length(data, r) : -1;
}
curl_off_t Curl_creader_client_length(struct Curl_easy *data)
struct Curl_creader *r = data->req.reader_stack;
while(r && r->phase != CURL_CR_CLIENT)
r = r->next;
- return r? r->crt->total_length(data, r) : -1;
+ return r ? r->crt->total_length(data, r) : -1;
}
CURLcode Curl_creader_resume_from(struct Curl_easy *data, curl_off_t offset)
struct Curl_creader *r = data->req.reader_stack;
while(r && r->phase != CURL_CR_CLIENT)
r = r->next;
- return r? r->crt->resume_from(data, r, offset) : CURLE_READ_ERROR;
+ return r ? r->crt->resume_from(data, r, offset) : CURLE_READ_ERROR;
}
CURLcode Curl_creader_unpause(struct Curl_easy *data)
size_t tlen;
str = strchr(str, ',');
- tlen = str? (size_t) (str - token): strlen(token);
+ tlen = str ? (size_t) (str - token) : strlen(token);
if(tlen) {
const struct Curl_handler *h = Curl_getn_scheme_handler(token, tlen);
#endif
#ifdef USE_LIBPSL
if(data->psl == &data->share->psl)
- data->psl = data->multi? &data->multi->psl: NULL;
+ data->psl = data->multi ? &data->multi->psl : NULL;
#endif
data->share->dirty--;
data->share->dirty++;
- if(data->share->specifier & (1<< CURL_LOCK_DATA_DNS)) {
+ if(data->share->specifier & (1 << CURL_LOCK_DATA_DNS)) {
/* use shared host cache */
data->dns.hostcache = &data->share->hostcache;
data->dns.hostcachetype = HCACHE_SHARED;
}
#endif
case CURLOPT_QUICK_EXIT:
- data->set.quick_exit = (0 != va_arg(param, long)) ? 1L:0L;
+ data->set.quick_exit = (0 != va_arg(param, long)) ? 1L : 0L;
break;
default:
/* unknown tag and its companion, just ignore: */
struct Curl_share *share = calloc(1, sizeof(struct Curl_share));
if(share) {
share->magic = CURL_GOOD_SHARE;
- share->specifier |= (1<<CURL_LOCK_DATA_SHARE);
+ share->specifier |= (1 << CURL_LOCK_DATA_SHARE);
Curl_init_dnscache(&share->hostcache, 23);
}
res = CURLSHE_BAD_OPTION;
}
if(!res)
- share->specifier |= (unsigned int)(1<<type);
+ share->specifier |= (unsigned int)(1 << type);
break;
case CURLSHOPT_UNSHARE:
/* this is a type this share will no longer share */
type = va_arg(param, int);
- share->specifier &= ~(unsigned int)(1<<type);
+ share->specifier &= ~(unsigned int)(1 << type);
switch(type) {
case CURL_LOCK_DATA_DNS:
break;
if(!share)
return CURLSHE_INVALID;
- if(share->specifier & (unsigned int)(1<<type)) {
+ if(share->specifier & (unsigned int)(1 << type)) {
if(share->lockfunc) /* only call this if set! */
share->lockfunc(data, type, accesstype, share->clientdata);
}
if(!share)
return CURLSHE_INVALID;
- if(share->specifier & (unsigned int)(1<<type)) {
+ if(share->specifier & (unsigned int)(1 << type)) {
if(share->unlockfunc) /* only call this if set! */
share->unlockfunc (data, type, share->clientdata);
}
/* Result */
switch(socksreq[1]) {
case 90:
- infof(data, "SOCKS4%s request granted.", protocol4a?"a":"");
+ infof(data, "SOCKS4%s request granted.", protocol4a ? "a" : "");
break;
case 91:
failf(data,
gss_enc = 1;
infof(data, "SOCKS5 server supports GSS-API %s data protection.",
- (gss_enc == 0)?"no":((gss_enc==1)?"integrity":"confidentiality"));
+ (gss_enc == 0) ? "no" :
+ ((gss_enc == 1) ? "integrity" : "confidentiality"));
/* force for the moment to no data protection */
gss_enc = 0;
/*
(void)curlx_nonblock(sock, TRUE);
infof(data, "SOCKS5 access with%s protection granted.",
- (socksreq[0] == 0)?"out GSS-API data":
- ((socksreq[0] == 1)?" GSS-API integrity":" GSS-API confidentiality"));
+ (socksreq[0] == 0) ? "out GSS-API data":
+ ((socksreq[0] == 1) ? " GSS-API integrity" :
+ " GSS-API confidentiality"));
conn->socks5_gssapi_enctype = socksreq[0];
if(socksreq[0] == 0)
gss_enc = 1;
infof(data, "SOCKS5 server supports GSS-API %s data protection.",
- (gss_enc == 0)?"no":((gss_enc == 1)?"integrity":"confidentiality") );
+ (gss_enc == 0) ? "no" :
+ ((gss_enc == 1) ? "integrity":"confidentiality") );
/* force to no data protection, avoid encryption/decryption for now */
gss_enc = 0;
/*
(void)curlx_nonblock(sock, TRUE);
infof(data, "SOCKS5 access with%s protection granted.",
- (socksreq[0] == 0)?"out GSS-API data":
- ((socksreq[0] == 1)?" GSS-API integrity":" GSS-API confidentiality"));
+ (socksreq[0] == 0) ? "out GSS-API data":
+ ((socksreq[0] == 1) ? " GSS-API integrity" :
+ " GSS-API confidentiality"));
/* For later use if encryption is required
conn->socks5_gssapi_enctype = socksreq[0];
if(data->set.verbose) {
unsigned int i = 0;
if(direction) {
- infof(data, "%s IAC SB ", (direction == '<')? "RCVD":"SENT");
+ infof(data, "%s IAC SB ", (direction == '<') ? "RCVD" : "SENT");
if(length >= 3) {
int j;
switch(pointer[0]) {
case CURL_TELOPT_NAWS:
if(length > 4)
- infof(data, "Width: %d ; Height: %d", (pointer[1]<<8) | pointer[2],
- (pointer[3]<<8) | pointer[4]);
+ infof(data, "Width: %d ; Height: %d", (pointer[1] << 8) | pointer[2],
+ (pointer[3] << 8) | pointer[4]);
break;
default:
switch(pointer[1]) {
state->retry_max = (int)timeout/5;
/* But bound the total number */
- if(state->retry_max<3)
+ if(state->retry_max < 3)
state->retry_max = 3;
- if(state->retry_max>50)
+ if(state->retry_max > 50)
state->retry_max = 50;
/* Compute the re-ACK interval to suit the timeout */
state->retry_time = (int)(timeout/state->retry_max);
- if(state->retry_time<1)
+ if(state->retry_time < 1)
state->retry_time = 1;
infof(state->data,
case TFTP_EVENT_TIMEOUT: /* Resend the first packet out */
/* Increment the retry counter, quit if over the limit */
state->retries++;
- if(state->retries>state->retry_max) {
+ if(state->retries > state->retry_max) {
state->error = TFTP_ERR_NORESPONSE;
state->state = TFTP_STATE_FIN;
return result;
4, SEND_4TH_ARG,
(struct sockaddr *)&state->remote_addr,
state->remote_addrlen);
- if(sbytes<0) {
+ if(sbytes < 0) {
failf(data, "%s", Curl_strerror(SOCKERRNO, buffer, sizeof(buffer)));
return CURLE_SEND_ERROR;
}
rblock, state->block);
state->retries++;
/* Bail out if over the maximum */
- if(state->retries>state->retry_max) {
+ if(state->retries > state->retry_max) {
failf(data, "tftp_tx: giving up waiting for block %d ack",
state->block);
result = CURLE_SEND_ERROR;
(struct sockaddr *)&state->remote_addr,
state->remote_addrlen);
/* Check all sbytes were sent */
- if(sbytes<0) {
+ if(sbytes < 0) {
failf(data, "%s", Curl_strerror(SOCKERRNO,
buffer, sizeof(buffer)));
result = CURLE_SEND_ERROR;
(struct sockaddr *)&state->remote_addr,
state->remote_addrlen);
/* Check all sbytes were sent */
- if(sbytes<0) {
+ if(sbytes < 0) {
failf(data, "%s", Curl_strerror(SOCKERRNO, buffer, sizeof(buffer)));
return CURLE_SEND_ERROR;
}
(struct sockaddr *)&state->remote_addr,
state->remote_addrlen);
/* Check all sbytes were sent */
- if(sbytes<0) {
+ if(sbytes < 0) {
failf(data, "%s", Curl_strerror(SOCKERRNO, buffer, sizeof(buffer)));
return CURLE_SEND_ERROR;
}
!(data->set.keep_post & CURL_REDIR_POST_303))) {
data->state.httpreq = HTTPREQ_GET;
infof(data, "Switch to %s",
- data->req.no_body?"HEAD":"GET");
+ data->req.no_body ? "HEAD" : "GET");
}
break;
case 304: /* Not Modified */
conn->sockfd = sockindex == -1 ?
CURL_SOCKET_BAD : conn->sock[sockindex];
conn->writesockfd = writesockindex == -1 ?
- CURL_SOCKET_BAD:conn->sock[writesockindex];
+ CURL_SOCKET_BAD : conn->sock[writesockindex];
}
k->getheader = getheader;
curl_off_t recv_size,
bool getheader)
{
- int recv_index = (send_recv & CURL_XFER_RECV)? FIRSTSOCKET : -1;
- int send_index = (send_recv & CURL_XFER_SEND)? FIRSTSOCKET : -1;
+ int recv_index = (send_recv & CURL_XFER_RECV) ? FIRSTSOCKET : -1;
+ int send_index = (send_recv & CURL_XFER_SEND) ? FIRSTSOCKET : -1;
DEBUGASSERT((recv_index >= 0) || (recv_size == -1));
xfer_setup(data, recv_index, recv_size, getheader, send_index, FALSE);
}
curl_off_t recv_size,
bool shutdown)
{
- int recv_index = (send_recv & CURL_XFER_RECV)? SECONDARYSOCKET : -1;
- int send_index = (send_recv & CURL_XFER_SEND)? SECONDARYSOCKET : -1;
+ int recv_index = (send_recv & CURL_XFER_RECV) ? SECONDARYSOCKET : -1;
+ int send_index = (send_recv & CURL_XFER_SEND) ? SECONDARYSOCKET : -1;
DEBUGASSERT((recv_index >= 0) || (recv_size == -1));
xfer_setup(data, recv_index, recv_size, FALSE, send_index, shutdown);
}
#ifndef CURL_DISABLE_PROXY
infof(data, "Re-using existing connection with %s %s",
- conn->bits.proxy?"proxy":"host",
+ conn->bits.proxy ? "proxy" : "host",
conn->socks_proxy.host.name ? conn->socks_proxy.host.dispname :
conn->http_proxy.host.name ? conn->http_proxy.host.dispname :
conn->host.dispname);
if(urlchar_needs_escaping(*iptr)) {
char out[3]={'%'};
- out[1] = hexdigits[*iptr>>4];
+ out[1] = hexdigits[*iptr >> 4];
out[2] = hexdigits[*iptr & 0xf];
result = Curl_dyn_addn(o, out, 3);
}
ccode = Curl_parse_login_details(login, ptr - login - 1,
&userp, &passwdp,
(h && (h->flags & PROTOPT_URLOPTIONS)) ?
- &optionsp:NULL);
+ &optionsp : NULL);
if(ccode) {
result = CURLUE_BAD_LOGIN;
goto out;
const char *ptr;
CURLUcode ifmissing = CURLUE_UNKNOWN_PART;
char portbuf[7];
- bool urldecode = (flags & CURLU_URLDECODE)?1:0;
- bool urlencode = (flags & CURLU_URLENCODE)?1:0;
+ bool urldecode = (flags & CURLU_URLDECODE) ? 1 : 0;
+ bool urlencode = (flags & CURLU_URLENCODE) ? 1 : 0;
bool punycode = FALSE;
bool depunyfy = FALSE;
bool plusdecode = FALSE;
case CURLUPART_HOST:
ptr = u->host;
ifmissing = CURLUE_NO_HOST;
- punycode = (flags & CURLU_PUNYCODE)?1:0;
- depunyfy = (flags & CURLU_PUNY2IDN)?1:0;
+ punycode = (flags & CURLU_PUNYCODE) ? 1 : 0;
+ depunyfy = (flags & CURLU_PUNY2IDN) ? 1 : 0;
break;
case CURLUPART_ZONEID:
ptr = u->zoneid;
bool show_query =
(u->query && u->query[0]) ||
(u->query_present && flags & CURLU_GET_EMPTY);
- punycode = (flags & CURLU_PUNYCODE)?1:0;
- depunyfy = (flags & CURLU_PUNY2IDN)?1:0;
+ punycode = (flags & CURLU_PUNYCODE) ? 1 : 0;
+ depunyfy = (flags & CURLU_PUNY2IDN) ? 1 : 0;
if(u->scheme && strcasecompare("file", u->scheme)) {
url = aprintf("file://%s%s%s",
u->path,
show_query ? "?": "",
u->query ? u->query : "",
show_fragment ? "#": "",
- u->fragment? u->fragment : "");
+ u->fragment ? u->fragment : "");
free(allochost);
}
if(!url)
const char *part, unsigned int flags)
{
char **storep = NULL;
- bool urlencode = (flags & CURLU_URLENCODE)? 1 : 0;
+ bool urlencode = (flags & CURLU_URLENCODE) ? 1 : 0;
bool plusencode = FALSE;
bool urlskipslash = FALSE;
bool leadingslash = FALSE;
break;
case CURLUPART_QUERY:
plusencode = urlencode;
- appendquery = (flags & CURLU_APPENDQUERY)?1:0;
+ appendquery = (flags & CURLU_APPENDQUERY) ? 1 : 0;
equalsencode = appendquery;
storep = &u->query;
u->query_present = TRUE;
}
else {
char out[3]={'%'};
- out[1] = hexdigits[*i>>4];
+ out[1] = hexdigits[*i >> 4];
out[2] = hexdigits[*i & 0xf];
result = Curl_dyn_addn(&enc, out, 3);
if(result)
gss_release_buffer(&unused_status, &output_token);
}
else
- Curl_bufref_set(out, mutual_auth? "": NULL, 0, NULL);
+ Curl_bufref_set(out, mutual_auth ? "": NULL, 0, NULL);
return result;
}
fprintf(handle, "NTLMFLAG_NEGOTIATE_OEM ");
if(flags & NTLMFLAG_REQUEST_TARGET)
fprintf(handle, "NTLMFLAG_REQUEST_TARGET ");
- if(flags & (1<<3))
+ if(flags & (1 << 3))
fprintf(handle, "NTLMFLAG_UNKNOWN_3 ");
if(flags & NTLMFLAG_NEGOTIATE_SIGN)
fprintf(handle, "NTLMFLAG_NEGOTIATE_SIGN ");
fprintf(handle, "NTLMFLAG_NEGOTIATE_LM_KEY ");
if(flags & NTLMFLAG_NEGOTIATE_NTLM_KEY)
fprintf(handle, "NTLMFLAG_NEGOTIATE_NTLM_KEY ");
- if(flags & (1<<10))
+ if(flags & (1 << 10))
fprintf(handle, "NTLMFLAG_UNKNOWN_10 ");
if(flags & NTLMFLAG_NEGOTIATE_ANONYMOUS)
fprintf(handle, "NTLMFLAG_NEGOTIATE_ANONYMOUS ");
fprintf(handle, "NTLMFLAG_REQUEST_NONNT_SESSION_KEY ");
if(flags & NTLMFLAG_NEGOTIATE_TARGET_INFO)
fprintf(handle, "NTLMFLAG_NEGOTIATE_TARGET_INFO ");
- if(flags & (1<<24))
+ if(flags & (1 << 24))
fprintf(handle, "NTLMFLAG_UNKNOWN_24 ");
- if(flags & (1<<25))
+ if(flags & (1 << 25))
fprintf(handle, "NTLMFLAG_UNKNOWN_25 ");
- if(flags & (1<<26))
+ if(flags & (1 << 26))
fprintf(handle, "NTLMFLAG_UNKNOWN_26 ");
- if(flags & (1<<27))
+ if(flags & (1 << 27))
fprintf(handle, "NTLMFLAG_UNKNOWN_27 ");
- if(flags & (1<<28))
+ if(flags & (1 << 28))
fprintf(handle, "NTLMFLAG_UNKNOWN_28 ");
if(flags & NTLMFLAG_NEGOTIATE_128)
fprintf(handle, "NTLMFLAG_NEGOTIATE_128 ");
default:
break;
}
- return cf->next?
+ return cf->next ?
cf->next->cft->query(cf->next, data, query, pres1, pres2) :
CURLE_UNKNOWN_OPTION;
}
result = Curl_cf_create(&cf, &Curl_cft_http3, ctx);
out:
- *pcf = (!result)? cf : NULL;
+ *pcf = (!result) ? cf : NULL;
if(result) {
Curl_safefree(cf);
cf_msh3_ctx_free(ctx);
const struct connectdata *conn,
int sockindex)
{
- struct Curl_cfilter *cf = conn? conn->cfilter[sockindex] : NULL;
+ struct Curl_cfilter *cf = conn ? conn->cfilter[sockindex] : NULL;
(void)data;
for(; cf; cf = cf->next) {
(void)cf;
if(stream->reset) {
failf(data, "HTTP/3 stream %" FMT_PRId64 " reset by server", stream->id);
- *err = data->req.bytecount? CURLE_PARTIAL_FILE : CURLE_HTTP3;
+ *err = data->req.bytecount ? CURLE_PARTIAL_FILE : CURLE_HTTP3;
goto out;
}
else if(!stream->resp_hds_complete) {
}
}
CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] cf_recv(blen=%zu) -> %zd, %d",
- stream? stream->id : -1, blen, nread, *err);
+ stream ? stream->id : -1, blen, nread, *err);
CF_DATA_RESTORE(cf, save);
return nread;
}
CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] read req body -> "
"%d vecs%s with %zu (buffered=%zu, left=%" FMT_OFF_T ")",
stream->id, (int)nvecs,
- *pflags == NGHTTP3_DATA_FLAG_EOF?" EOF":"",
+ *pflags == NGHTTP3_DATA_FLAG_EOF ? " EOF" : "",
nwritten, Curl_bufq_len(&stream->sendbuf),
stream->upload_left);
return (nghttp3_ssize)nvecs;
sent = -1;
}
CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] cf_send(len=%zu) -> %zd, %d",
- stream? stream->id : -1, len, sent, *err);
+ stream ? stream->id : -1, len, sent, *err);
CF_DATA_RESTORE(cf, save);
return sent;
}
ngtcp2_crypto_conn_ref *cref;
cref = (ngtcp2_crypto_conn_ref *)SSL_get_app_data(ssl);
- cf = cref? cref->user_data : NULL;
- ctx = cf? cf->ctx : NULL;
- data = cf? CF_DATA_CURRENT(cf) : NULL;
+ cf = cref ? cref->user_data : NULL;
+ ctx = cf ? cf->ctx : NULL;
+ data = cf ? CF_DATA_CURRENT(cf) : NULL;
if(cf && data && ctx) {
Curl_ossl_add_session(cf, data, &ctx->peer, ssl_sessionid);
return 1;
if(ctx->max_bidi_streams > ctx->used_bidi_streams)
avail_bidi_streams = ctx->max_bidi_streams - ctx->used_bidi_streams;
max_streams += avail_bidi_streams;
- *pres1 = (max_streams > INT_MAX)? INT_MAX : (int)max_streams;
+ *pres1 = (max_streams > INT_MAX) ? INT_MAX : (int)max_streams;
}
else /* transport params not arrived yet? take our default. */
*pres1 = (int)Curl_multi_max_concurrent_streams(data->multi);
case CF_QUERY_CONNECT_REPLY_MS:
if(ctx->q.got_first_byte) {
timediff_t ms = Curl_timediff(ctx->q.first_byte_at, ctx->started_at);
- *pres1 = (ms < INT_MAX)? (int)ms : INT_MAX;
+ *pres1 = (ms < INT_MAX) ? (int)ms : INT_MAX;
}
else
*pres1 = -1;
default:
break;
}
- return cf->next?
+ return cf->next ?
cf->next->cft->query(cf->next, data, query, pres1, pres2) :
CURLE_UNKNOWN_OPTION;
}
cf->next = udp_cf;
out:
- *pcf = (!result)? cf : NULL;
+ *pcf = (!result) ? cf : NULL;
if(result) {
if(udp_cf)
Curl_conn_cf_discard_sub(cf, udp_cf, data, TRUE);
const struct connectdata *conn,
int sockindex)
{
- struct Curl_cfilter *cf = conn? conn->cfilter[sockindex] : NULL;
+ struct Curl_cfilter *cf = conn ? conn->cfilter[sockindex] : NULL;
(void)data;
for(; cf; cf = cf->next) {
CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] read req body -> "
"%d vecs%s with %zu (buffered=%zu, left=%" FMT_OFF_T ")",
stream->s.id, (int)nvecs,
- *pflags == NGHTTP3_DATA_FLAG_EOF?" EOF":"",
+ *pflags == NGHTTP3_DATA_FLAG_EOF ? " EOF" : "",
nwritten, Curl_bufq_len(&stream->sendbuf),
stream->upload_left);
return (nghttp3_ssize)nvecs;
for(i = 0; (i < n) && !blocked; ++i) {
/* Without stream->s.ssl, we closed that already, so
* pretend the write did succeed. */
- uint64_t flags = (eos && ((i + 1) == n))? SSL_WRITE_FLAG_CONCLUDE : 0;
+ uint64_t flags = (eos && ((i + 1) == n)) ? SSL_WRITE_FLAG_CONCLUDE : 0;
written = vec[i].len;
ok = !s->ssl || SSL_write_ex2(s->ssl, vec[i].base, vec[i].len, flags,
&written);
out:
result = check_and_set_expiry(cf, data);
CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] cf_send(len=%zu) -> %zd, %d",
- stream? stream->s.id : -1, len, nwritten, *err);
+ stream ? stream->s.id : -1, len, nwritten, *err);
CF_DATA_RESTORE(cf, save);
return nwritten;
}
failf(data,
"HTTP/3 stream %" FMT_PRId64 " reset by server",
stream->s.id);
- *err = data->req.bytecount? CURLE_PARTIAL_FILE : CURLE_HTTP3;
+ *err = data->req.bytecount ? CURLE_PARTIAL_FILE : CURLE_HTTP3;
goto out;
}
else if(!stream->resp_hds_complete) {
}
}
CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] cf_recv(len=%zu) -> %zd, %d",
- stream? stream->s.id : -1, len, nread, *err);
+ stream ? stream->s.id : -1, len, nread, *err);
CF_DATA_RESTORE(cf, save);
return nread;
}
}
/* we report avail + in_use */
v += CONN_INUSE(cf->conn);
- *pres1 = (v > INT_MAX)? INT_MAX : (int)v;
+ *pres1 = (v > INT_MAX) ? INT_MAX : (int)v;
#else
*pres1 = 100;
#endif
case CF_QUERY_CONNECT_REPLY_MS:
if(ctx->got_first_byte) {
timediff_t ms = Curl_timediff(ctx->first_byte_at, ctx->started_at);
- *pres1 = (ms < INT_MAX)? (int)ms : INT_MAX;
+ *pres1 = (ms < INT_MAX) ? (int)ms : INT_MAX;
}
else
*pres1 = -1;
default:
break;
}
- return cf->next?
+ return cf->next ?
cf->next->cft->query(cf->next, data, query, pres1, pres2) :
CURLE_UNKNOWN_OPTION;
}
cf->next = udp_cf;
out:
- *pcf = (!result)? cf : NULL;
+ *pcf = (!result) ? cf : NULL;
if(result) {
if(udp_cf)
Curl_conn_cf_discard_sub(cf, udp_cf, data, TRUE);
const struct connectdata *conn,
int sockindex)
{
- struct Curl_cfilter *cf = conn? conn->cfilter[sockindex] : NULL;
+ struct Curl_cfilter *cf = conn ? conn->cfilter[sockindex] : NULL;
(void)data;
for(; cf; cf = cf->next) {
if(stream->reset) {
failf(data,
"HTTP/3 stream %" FMT_PRIu64 " reset by server", stream->id);
- *err = data->req.bytecount? CURLE_PARTIAL_FILE : CURLE_HTTP3;
+ *err = data->req.bytecount ? CURLE_PARTIAL_FILE : CURLE_HTTP3;
CURL_TRC_CF(data, cf, "[%" FMT_PRIu64 "] cf_recv, was reset -> %d",
stream->id, *err);
}
nwritten = -1;
}
CURL_TRC_CF(data, cf, "[%" FMT_PRIu64 "] cf_send(len=%zu) -> %zd, %d",
- stream? stream->id : (curl_uint64_t)~0, len, nwritten, *err);
+ stream ? stream->id : (curl_uint64_t)~0, len, nwritten, *err);
return nwritten;
}
if(!ctx->goaway) {
max_streams += quiche_conn_peer_streams_left_bidi(ctx->qconn);
}
- *pres1 = (max_streams > INT_MAX)? INT_MAX : (int)max_streams;
+ *pres1 = (max_streams > INT_MAX) ? INT_MAX : (int)max_streams;
CURL_TRC_CF(data, cf, "query conn[%" FMT_OFF_T "]: "
"MAX_CONCURRENT -> %d (%zu in use)",
cf->conn->connection_id, *pres1, CONN_INUSE(cf->conn));
case CF_QUERY_CONNECT_REPLY_MS:
if(ctx->q.got_first_byte) {
timediff_t ms = Curl_timediff(ctx->q.first_byte_at, ctx->started_at);
- *pres1 = (ms < INT_MAX)? (int)ms : INT_MAX;
+ *pres1 = (ms < INT_MAX) ? (int)ms : INT_MAX;
}
else
*pres1 = -1;
default:
break;
}
- return cf->next?
+ return cf->next ?
cf->next->cft->query(cf->next, data, query, pres1, pres2) :
CURLE_UNKNOWN_OPTION;
}
cf->next = udp_cf;
out:
- *pcf = (!result)? cf : NULL;
+ *pcf = (!result) ? cf : NULL;
if(result) {
if(udp_cf)
Curl_conn_cf_discard_sub(cf, udp_cf, data, TRUE);
const struct connectdata *conn,
int sockindex)
{
- struct Curl_cfilter *cf = conn? conn->cfilter[sockindex] : NULL;
+ struct Curl_cfilter *cf = conn ? conn->cfilter[sockindex] : NULL;
(void)data;
for(; cf; cf = cf->next) {
(void)clientp;
/* we only allow perfect matches, and we reject everything else */
- return (match != CURLKHMATCH_OK)?CURLKHSTAT_REJECT:CURLKHSTAT_FINE;
+ return (match != CURLKHMATCH_OK) ? CURLKHSTAT_REJECT : CURLKHSTAT_FINE;
}
#endif
#ifdef HAVE_LIBSSH2_KNOWNHOST_CHECKP
keycheck = libssh2_knownhost_checkp(sshc->kh,
conn->host.name,
- (conn->remote_port != PORT_SSH)?
- conn->remote_port:-1,
+ (conn->remote_port != PORT_SSH) ?
+ conn->remote_port : -1,
remotekey, keylen,
LIBSSH2_KNOWNHOST_TYPE_PLAIN|
LIBSSH2_KNOWNHOST_KEYENC_RAW|
#endif
infof(data, "SSH host check: %d, key: %s", keycheck,
- (keycheck <= LIBSSH2_KNOWNHOST_CHECK_MISMATCH)?
- host->key:"<none>");
+ (keycheck <= LIBSSH2_KNOWNHOST_CHECK_MISMATCH) ?
+ host->key : "<none>");
/* setup 'knownkey' */
if(keycheck <= LIBSSH2_KNOWNHOST_CHECK_MISMATCH) {
if(sshc->secondCreateDirs) {
state(data, SSH_SFTP_CLOSE);
sshc->actualcode = sftperr != LIBSSH2_FX_OK ?
- sftp_libssh2_error_to_CURLE(sftperr):CURLE_SSH;
+ sftp_libssh2_error_to_CURLE(sftperr) : CURLE_SSH;
failf(data, "Creating the dir/file failed: %s",
sftp_libssh2_strerror(sftperr));
break;
}
state(data, SSH_SFTP_CLOSE);
sshc->actualcode = sftperr != LIBSSH2_FX_OK ?
- sftp_libssh2_error_to_CURLE(sftperr):CURLE_SSH;
+ sftp_libssh2_error_to_CURLE(sftperr) : CURLE_SSH;
if(!sshc->actualcode) {
/* Sometimes, for some reason libssh2_sftp_last_error() returns zero
even though libssh2_sftp_open() failed previously! We need to
}
failf(data, "Upload failed: %s (%lu/%d)",
sftperr != LIBSSH2_FX_OK ?
- sftp_libssh2_strerror(sftperr):"ssh error",
+ sftp_libssh2_strerror(sftperr) : "ssh error",
sftperr, rc);
break;
}
dir = libssh2_session_block_directions(sshc->ssh_session);
if(dir) {
/* translate the libssh2 define bits into our own bit defines */
- conn->waitfor = ((dir&LIBSSH2_SESSION_BLOCK_INBOUND)?KEEP_RECV:0) |
- ((dir&LIBSSH2_SESSION_BLOCK_OUTBOUND)?KEEP_SEND:0);
+ conn->waitfor = ((dir&LIBSSH2_SESSION_BLOCK_INBOUND) ? KEEP_RECV : 0) |
+ ((dir&LIBSSH2_SESSION_BLOCK_OUTBOUND) ? KEEP_SEND : 0);
}
}
if(!dir)
fd_write = sock;
/* wait for the socket to become ready */
(void)Curl_socket_check(fd_read, CURL_SOCKET_BAD, fd_write,
- left>1000?1000:left);
+ left > 1000 ? 1000 : left);
}
}
(void)sockindex;
(void)eos;
- offset[0] = (word32)sshc->offset&0xFFFFFFFF;
- offset[1] = (word32)(sshc->offset>>32)&0xFFFFFFFF;
+ offset[0] = (word32)sshc->offset & 0xFFFFFFFF;
+ offset[1] = (word32)(sshc->offset >> 32) & 0xFFFFFFFF;
rc = wolfSSH_SFTP_SendWritePacket(sshc->ssh_session, sshc->handle,
sshc->handleSz,
word32 offset[2];
(void)sockindex;
- offset[0] = (word32)sshc->offset&0xFFFFFFFF;
- offset[1] = (word32)(sshc->offset>>32)&0xFFFFFFFF;
+ offset[0] = (word32)sshc->offset & 0xFFFFFFFF;
+ offset[1] = (word32)(sshc->offset >> 32) & 0xFFFFFFFF;
rc = wolfSSH_SFTP_SendReadPacket(sshc->ssh_session, sshc->handle,
sshc->handleSz,
return CURLE_SSH;
}
- size = ((curl_off_t)attrs.sz[1] <<32) | attrs.sz[0];
+ size = ((curl_off_t)attrs.sz[1] << 32) | attrs.sz[0];
data->req.size = size;
data->req.maxdownload = size;
/* wait for the socket to become ready */
(void)Curl_socket_check(fd_read, CURL_SOCKET_BAD, fd_write,
- left>1000?1000:left); /* ignore result */
+ left > 1000 ? 1000 : left); /* ignore result */
}
}
proto = br_ssl_engine_get_selected_protocol(&backend->ctx.eng);
Curl_alpn_set_negotiated(cf, data, (const unsigned char *)proto,
- proto? strlen(proto) : 0);
+ proto ? strlen(proto) : 0);
}
if(ssl_config->primary.cache_session) {
/* if ssl is expecting something, check if it is available. */
if(connssl->io_need) {
-
- curl_socket_t writefd = (connssl->io_need & CURL_SSL_IO_NEED_SEND)?
- sockfd:CURL_SOCKET_BAD;
- curl_socket_t readfd = (connssl->io_need & CURL_SSL_IO_NEED_RECV)?
- sockfd:CURL_SOCKET_BAD;
+ curl_socket_t writefd = (connssl->io_need & CURL_SSL_IO_NEED_SEND) ?
+ sockfd : CURL_SOCKET_BAD;
+ curl_socket_t readfd = (connssl->io_need & CURL_SSL_IO_NEED_RECV) ?
+ sockfd : CURL_SOCKET_BAD;
CURL_TRC_CF(data, cf, "connect_common, check socket");
what = Curl_socket_check(readfd, CURL_SOCKET_BAD, writefd,
- nonblocking?0:timeout_ms);
+ nonblocking ? 0 : timeout_ms);
CURL_TRC_CF(data, cf, "connect_common, check socket -> %d", what);
if(what < 0) {
/* fatal error */
backend->gtls.io_result = result;
if(nwritten < 0) {
gnutls_transport_set_errno(backend->gtls.session,
- (CURLE_AGAIN == result)? EAGAIN : EINVAL);
+ (CURLE_AGAIN == result) ? EAGAIN : EINVAL);
nwritten = -1;
}
return nwritten;
backend->gtls.io_result = result;
if(nread < 0) {
gnutls_transport_set_errno(backend->gtls.session,
- (CURLE_AGAIN == result)? EAGAIN : EINVAL);
+ (CURLE_AGAIN == result) ? EAGAIN : EINVAL);
nread = -1;
}
else if(nread == 0)
{
int ret = 1;
if(!gtls_inited) {
- ret = gnutls_global_init()?0:1;
+ ret = gnutls_global_init() ? 0 : 1;
#ifdef GTLSDEBUG
gnutls_global_set_log_function(tls_log_func);
gnutls_global_set_log_level(2);
sizeof(str),
" %s: %s, %02d %s %4d %02d:%02d:%02d GMT",
text,
- Curl_wkday[tm->tm_wday?tm->tm_wday-1:6],
+ Curl_wkday[tm->tm_wday ? tm->tm_wday-1 : 6],
tm->tm_mday,
Curl_month[tm->tm_mon],
tm->tm_year + 1900,
/* if ssl is expecting something, check if it is available. */
if(connssl->io_need) {
int what;
- curl_socket_t writefd = (connssl->io_need & CURL_SSL_IO_NEED_SEND)?
- sockfd:CURL_SOCKET_BAD;
- curl_socket_t readfd = (connssl->io_need & CURL_SSL_IO_NEED_RECV)?
- sockfd:CURL_SOCKET_BAD;
+ curl_socket_t writefd = (connssl->io_need & CURL_SSL_IO_NEED_SEND) ?
+ sockfd : CURL_SOCKET_BAD;
+ curl_socket_t readfd = (connssl->io_need & CURL_SSL_IO_NEED_RECV) ?
+ sockfd : CURL_SOCKET_BAD;
what = Curl_socket_check(readfd, CURL_SOCKET_BAD, writefd,
- nonblocking?0:
- timeout_ms?timeout_ms:1000);
+ nonblocking ? 0 :
+ timeout_ms ? timeout_ms : 1000);
if(what < 0) {
/* fatal error */
failf(data, "select/poll on SSL socket, errno: %d", SOCKERRNO);
if((rc == GNUTLS_E_AGAIN) || (rc == GNUTLS_E_INTERRUPTED)) {
connssl->io_need =
- gnutls_record_get_direction(session)?
- CURL_SSL_IO_NEED_SEND:CURL_SSL_IO_NEED_RECV;
+ gnutls_record_get_direction(session) ?
+ CURL_SSL_IO_NEED_SEND : CURL_SSL_IO_NEED_RECV;
continue;
}
else if((rc < 0) && !gnutls_error_is_fatal(rc)) {
struct Curl_easy *data = CF_DATA_CURRENT(cf);
if(data) {
CURL_TRC_CF(data, cf, "handshake: %s message type %d",
- incoming? "incoming" : "outgoing", htype);
+ incoming ? "incoming" : "outgoing", htype);
switch(htype) {
case GNUTLS_HANDSHAKE_NEW_SESSION_TICKET: {
gtls_update_session_id(cf, data, session);
cause = "attached OCSP status response is invalid";
failf(data, "server verification failed: %s. (CAfile: %s "
"CRLfile: %s)", cause,
- config->CAfile ? config->CAfile: "none",
+ config->CAfile ? config->CAfile : "none",
ssl_config->primary.CRLfile ?
ssl_config->primary.CRLfile : "none");
return CURLE_PEER_FAILED_VERIFICATION;
unload_file(issuerp);
if(rc <= 0) {
failf(data, "server certificate issuer check failed (IssuerCert: %s)",
- config->issuercert?config->issuercert:"none");
+ config->issuercert ? config->issuercert : "none");
gnutls_x509_crt_deinit(x509_cert);
return CURLE_SSL_ISSUER_ERROR;
}
infof(data, " server certificate issuer check OK (Issuer Cert: %s)",
- config->issuercert?config->issuercert:"none");
+ config->issuercert ? config->issuercert : "none");
}
size = sizeof(certname);
struct ssl_primary_config *conn_config = Curl_ssl_cf_get_primary_config(cf);
struct ssl_config_data *ssl_config = Curl_ssl_cf_get_config(cf, data);
#ifndef CURL_DISABLE_PROXY
- const char *pinned_key = Curl_ssl_cf_is_proxy(cf)?
- data->set.str[STRING_SSL_PINNEDPUBLICKEY_PROXY]:
+ const char *pinned_key = Curl_ssl_cf_is_proxy(cf) ?
+ data->set.str[STRING_SSL_PINNEDPUBLICKEY_PROXY] :
data->set.str[STRING_SSL_PINNEDPUBLICKEY];
#else
const char *pinned_key = data->set.str[STRING_SSL_PINNEDPUBLICKEY];
rc = (ssize_t)total_written;
goto out;
}
- *curlcode = (rc == GNUTLS_E_AGAIN)?
+ *curlcode = (rc == GNUTLS_E_AGAIN) ?
CURLE_AGAIN :
- (backend->gtls.io_result? backend->gtls.io_result : CURLE_SEND_ERROR);
+ (backend->gtls.io_result ? backend->gtls.io_result : CURLE_SEND_ERROR);
rc = -1;
goto out;
int ret = gnutls_bye(backend->gtls.session, GNUTLS_SHUT_RDWR);
if((ret == GNUTLS_E_AGAIN) || (ret == GNUTLS_E_INTERRUPTED)) {
CURL_TRC_CF(data, cf, "SSL shutdown, gnutls_bye EAGAIN");
- connssl->io_need = gnutls_record_get_direction(backend->gtls.session)?
+ connssl->io_need = gnutls_record_get_direction(backend->gtls.session) ?
CURL_SSL_IO_NEED_SEND : CURL_SSL_IO_NEED_RECV;
backend->gtls.sent_shutdown = FALSE;
result = CURLE_OK;
*done = TRUE;
}
else if((nread == GNUTLS_E_AGAIN) || (nread == GNUTLS_E_INTERRUPTED)) {
- connssl->io_need = gnutls_record_get_direction(backend->gtls.session)?
+ connssl->io_need = gnutls_record_get_direction(backend->gtls.session) ?
CURL_SSL_IO_NEED_SEND : CURL_SSL_IO_NEED_RECV;
}
else {
if(ret < 0) {
failf(data, "GnuTLS recv error (%d): %s",
-
(int)ret, gnutls_strerror((int)ret));
- *curlcode = backend->gtls.io_result?
- backend->gtls.io_result : CURLE_RECV_ERROR;
+ *curlcode = backend->gtls.io_result ?
+ backend->gtls.io_result : CURLE_RECV_ERROR;
ret = -1;
goto out;
}
int rc;
(void)data;
rc = gnutls_rnd(GNUTLS_RND_RANDOM, entropy, length);
- return rc?CURLE_FAILED_INIT:CURLE_OK;
+ return rc ? CURLE_FAILED_INIT : CURLE_OK;
}
static CURLcode gtls_sha256sum(const unsigned char *tmp, /* input */
ret = mbedtls_x509_crt_parse(&backend->cacert, newblob,
ca_info_blob->len + 1);
free(newblob);
- if(ret<0) {
+ if(ret < 0) {
mbedtls_strerror(ret, errorbuf, sizeof(errorbuf));
failf(data, "Error importing ca cert blob - mbedTLS: (-0x%04X) %s",
-ret, errorbuf);
#ifdef MBEDTLS_FS_IO
ret = mbedtls_x509_crt_parse_file(&backend->cacert, ssl_cafile);
- if(ret<0) {
+ if(ret < 0) {
mbedtls_strerror(ret, errorbuf, sizeof(errorbuf));
failf(data, "Error reading ca cert file %s - mbedTLS: (-0x%04X) %s",
ssl_cafile, -ret, errorbuf);
#ifdef MBEDTLS_FS_IO
ret = mbedtls_x509_crt_parse_path(&backend->cacert, ssl_capath);
- if(ret<0) {
+ if(ret < 0) {
mbedtls_strerror(ret, errorbuf, sizeof(errorbuf));
failf(data, "Error reading ca cert path %s - mbedTLS: (-0x%04X) %s",
ssl_capath, -ret, errorbuf);
&backend->clicert, &backend->pk);
}
- if(mbedtls_ssl_set_hostname(&backend->ssl, connssl->peer.sni?
+ if(mbedtls_ssl_set_hostname(&backend->ssl, connssl->peer.sni ?
connssl->peer.sni : connssl->peer.hostname)) {
/* mbedtls_ssl_set_hostname() sets the name to use in CN/SAN checks and
the name to set in the SNI extension. So even if curl connects to a
struct mbed_ssl_backend_data *backend =
(struct mbed_ssl_backend_data *)connssl->backend;
#ifndef CURL_DISABLE_PROXY
- const char * const pinnedpubkey = Curl_ssl_cf_is_proxy(cf)?
- data->set.str[STRING_SSL_PINNEDPUBLICKEY_PROXY]:
+ const char * const pinnedpubkey = Curl_ssl_cf_is_proxy(cf) ?
+ data->set.str[STRING_SSL_PINNEDPUBLICKEY_PROXY] :
data->set.str[STRING_SSL_PINNEDPUBLICKEY];
#else
const char * const pinnedpubkey = data->set.str[STRING_SSL_PINNEDPUBLICKEY];
const char *proto = mbedtls_ssl_get_alpn_protocol(&backend->ssl);
Curl_alpn_set_negotiated(cf, data, (const unsigned char *)proto,
- proto? strlen(proto) : 0);
+ proto ? strlen(proto) : 0);
}
#endif
#ifdef TLS13_SUPPORT
|| (ret == MBEDTLS_ERR_SSL_RECEIVED_NEW_SESSION_TICKET)
#endif
- )? CURLE_AGAIN : CURLE_SEND_ERROR;
+ ) ? CURLE_AGAIN : CURLE_SEND_ERROR;
ret = -1;
}
#ifdef MBEDTLS_VERSION_C
/* if mbedtls_version_get_number() is available it is better */
unsigned int version = mbedtls_version_get_number();
- return msnprintf(buffer, size, "mbedTLS/%u.%u.%u", version>>24,
- (version>>16)&0xff, (version>>8)&0xff);
+ return msnprintf(buffer, size, "mbedTLS/%u.%u.%u", version >> 24,
+ (version >> 16) & 0xff, (version >> 8) & 0xff);
#else
return msnprintf(buffer, size, "mbedTLS/%s", MBEDTLS_VERSION_STRING);
#endif
/* if ssl is expecting something, check if it is available. */
if(connssl->io_need) {
-
- curl_socket_t writefd = (connssl->io_need & CURL_SSL_IO_NEED_SEND)?
- sockfd:CURL_SOCKET_BAD;
- curl_socket_t readfd = (connssl->io_need & CURL_SSL_IO_NEED_RECV)?
- sockfd:CURL_SOCKET_BAD;
+ curl_socket_t writefd = (connssl->io_need & CURL_SSL_IO_NEED_SEND) ?
+ sockfd : CURL_SOCKET_BAD;
+ curl_socket_t readfd = (connssl->io_need & CURL_SSL_IO_NEED_RECV) ?
+ sockfd : CURL_SOCKET_BAD;
what = Curl_socket_check(readfd, CURL_SOCKET_BAD, writefd,
nonblocking ? 0 : timeout_ms);
SSL_CTX_use_PrivateKey_file(ctx, key_file, file_type);
if(cert_use_result != 1) {
failf(data, "unable to set private key file: '%s' type %s",
- key_file?key_file:"(memory blob)", key_type?key_type:"PEM");
+ key_file ? key_file : "(memory blob)",
+ key_type ? key_type : "PEM");
return 0;
}
break;
txt_len = msnprintf(ssl_buf, sizeof(ssl_buf),
"%s (%s), %s, %s (%d):\n",
- verstr, direction?"OUT":"IN",
+ verstr, direction ? "OUT" : "IN",
tls_rt_name, msg_name, msg_type);
if(0 <= txt_len && (unsigned)txt_len < sizeof(ssl_buf)) {
Curl_debug(data, CURLINFO_TEXT, ssl_buf, (size_t)txt_len);
struct ssl_connect_data *connssl;
cf = (struct Curl_cfilter*) SSL_get_app_data(ssl);
- connssl = cf? cf->ctx : NULL;
- data = connssl? CF_DATA_CURRENT(cf) : NULL;
+ connssl = cf ? cf->ctx : NULL;
+ data = connssl ? CF_DATA_CURRENT(cf) : NULL;
Curl_ossl_add_session(cf, data, &connssl->peer, ssl_sessionid);
return 0;
}
bool imported_ca_info_blob = false;
CURL_TRC_CF(data, cf, "populate_x509_store, path=%s, blob=%d",
- ssl_cafile? ssl_cafile : "none", !!ca_info_blob);
+ ssl_cafile ? ssl_cafile : "none", !!ca_info_blob);
if(!store)
return CURLE_OUT_OF_MEMORY;
X509_STORE *store = NULL;
DEBUGASSERT(multi);
- share = multi? Curl_hash_pick(&multi->proto_hash,
- (void *)MPROTO_OSSL_X509_KEY,
- sizeof(MPROTO_OSSL_X509_KEY)-1) : NULL;
+ share = multi ? Curl_hash_pick(&multi->proto_hash,
+ (void *)MPROTO_OSSL_X509_KEY,
+ sizeof(MPROTO_OSSL_X509_KEY)-1) : NULL;
if(share && share->store &&
!cached_x509_store_expired(data, share) &&
!cached_x509_store_different(cf, share)) {
infof(data, "SSL connection using %s / %s / %s / %s",
SSL_get_version(octx->ssl),
SSL_get_cipher(octx->ssl),
- negotiated_group_name? negotiated_group_name : "[blank]",
+ negotiated_group_name ? negotiated_group_name : "[blank]",
OBJ_nid2sn(psigtype_nid));
#ifdef USE_ECH
infof(data, "ECH: unexpected status %d",rv);
}
infof(data, "ECH: result: status is %s, inner is %s, outer is %s",
- (status ? status : "NULL"),
- (inner ? inner : "NULL"),
- (outer ? outer : "NULL"));
+ (status ? status : "NULL"),
+ (inner ? inner : "NULL"),
+ (outer ? outer : "NULL"));
OPENSSL_free(inner);
OPENSSL_free(outer);
if(rv == SSL_ECH_STATUS_GREASE_ECH) {
}
infof(data, "%s certificate:",
- Curl_ssl_cf_is_proxy(cf)? "Proxy" : "Server");
+ Curl_ssl_cf_is_proxy(cf) ? "Proxy" : "Server");
rc = x509_name_oneline(X509_get_subject_name(octx->server_cert),
buffer, sizeof(buffer));
- infof(data, " subject: %s", rc?"[NONE]":buffer);
+ infof(data, " subject: %s", rc ? "[NONE]" : buffer);
#ifndef CURL_DISABLE_VERBOSE_STRINGS
{
result = CURLE_OK;
#ifndef CURL_DISABLE_PROXY
- ptr = Curl_ssl_cf_is_proxy(cf)?
- data->set.str[STRING_SSL_PINNEDPUBLICKEY_PROXY]:
+ ptr = Curl_ssl_cf_is_proxy(cf) ?
+ data->set.str[STRING_SSL_PINNEDPUBLICKEY_PROXY] :
data->set.str[STRING_SSL_PINNEDPUBLICKEY];
#else
ptr = data->set.str[STRING_SSL_PINNEDPUBLICKEY];
/* if ssl is expecting something, check if it is available. */
if(!nonblocking && connssl->io_need) {
-
- curl_socket_t writefd = (connssl->io_need & CURL_SSL_IO_NEED_SEND)?
- sockfd:CURL_SOCKET_BAD;
- curl_socket_t readfd = (connssl->io_need & CURL_SSL_IO_NEED_RECV)?
- sockfd:CURL_SOCKET_BAD;
+ curl_socket_t writefd = (connssl->io_need & CURL_SSL_IO_NEED_SEND) ?
+ sockfd : CURL_SOCKET_BAD;
+ curl_socket_t readfd = (connssl->io_need & CURL_SSL_IO_NEED_RECV) ?
+ sockfd : CURL_SOCKET_BAD;
what = Curl_socket_check(readfd, CURL_SOCKET_BAD, writefd,
timeout_ms);
#else
return msnprintf(buffer, size, "%s/%lx.%lx.%lx",
OSSL_PACKAGE,
- (LIBRESSL_VERSION_NUMBER>>28)&0xf,
- (LIBRESSL_VERSION_NUMBER>>20)&0xff,
- (LIBRESSL_VERSION_NUMBER>>12)&0xff);
+ (LIBRESSL_VERSION_NUMBER >> 28) & 0xf,
+ (LIBRESSL_VERSION_NUMBER >> 20) & 0xff,
+ (LIBRESSL_VERSION_NUMBER >> 12) & 0xff);
#endif
#elif defined(OPENSSL_IS_BORINGSSL)
#ifdef CURL_BORINGSSL_VERSION
#endif
,
OSSL_PACKAGE,
- (ssleay_value>>28)&0xf,
- (ssleay_value>>20)&0xff,
- (ssleay_value>>12)&0xff,
+ (ssleay_value >> 28) & 0xf,
+ (ssleay_value >> 20) & 0xff,
+ (ssleay_value >> 12) & 0xff,
sub);
#endif /* OPENSSL_IS_BORINGSSL */
}
return CURLE_OPERATION_TIMEDOUT;
}
- socket_check_timeout = blocking?timeout_ms:0;
+ socket_check_timeout = blocking ? timeout_ms : 0;
what = Curl_socket_check(readfd, CURL_SOCKET_BAD, writefd,
socket_check_timeout);
/* A hostname associated with the credential is needed by
InitializeSecurityContext for SNI and other reasons. */
- snihost = connssl->peer.sni? connssl->peer.sni : connssl->peer.hostname;
+ snihost = connssl->peer.sni ? connssl->peer.sni : connssl->peer.hostname;
backend->cred->sni_hostname = curlx_convert_UTF8_to_tchar(snihost);
if(!backend->cred->sni_hostname)
return CURLE_OUT_OF_MEMORY;
DEBUGASSERT(backend);
- doread = (connssl->io_need & CURL_SSL_IO_NEED_SEND)? FALSE : TRUE;
+ doread = (connssl->io_need & CURL_SSL_IO_NEED_SEND) ? FALSE : TRUE;
connssl->io_need = CURL_SSL_IO_NEED_NONE;
DEBUGF(infof(data,
}
#ifndef CURL_DISABLE_PROXY
- pubkey_ptr = Curl_ssl_cf_is_proxy(cf)?
- data->set.str[STRING_SSL_PINNEDPUBLICKEY_PROXY]:
+ pubkey_ptr = Curl_ssl_cf_is_proxy(cf) ?
+ data->set.str[STRING_SSL_PINNEDPUBLICKEY_PROXY] :
data->set.str[STRING_SSL_PINNEDPUBLICKEY];
#else
pubkey_ptr = data->set.str[STRING_SSL_PINNEDPUBLICKEY];
/* if ssl is expecting something, check if it is available. */
if(connssl->io_need) {
- curl_socket_t writefd = (connssl->io_need & CURL_SSL_IO_NEED_SEND)?
- sockfd : CURL_SOCKET_BAD;
- curl_socket_t readfd = (connssl->io_need & CURL_SSL_IO_NEED_RECV)?
- sockfd : CURL_SOCKET_BAD;
+ curl_socket_t writefd = (connssl->io_need & CURL_SSL_IO_NEED_SEND) ?
+ sockfd : CURL_SOCKET_BAD;
+ curl_socket_t readfd = (connssl->io_need & CURL_SSL_IO_NEED_RECV) ?
+ sockfd : CURL_SOCKET_BAD;
what = Curl_socket_check(readfd, CURL_SOCKET_BAD, writefd,
nonblocking ? 0 : timeout_ms);
const char *current_ca_file_ptr = ca_buffer;
const char *ca_buffer_limit = ca_buffer + ca_buffer_size;
- while(more_certs && (current_ca_file_ptr<ca_buffer_limit)) {
+ while(more_certs && (current_ca_file_ptr < ca_buffer_limit)) {
const char *begin_cert_ptr = c_memmem(current_ca_file_ptr,
ca_buffer_limit-current_ca_file_ptr,
BEGIN_CERT,
keys_list_count = CFArrayGetCount(keys_list);
*out_cert_and_key = NULL;
status = 1;
- for(i = 0; i<keys_list_count; i++) {
+ for(i = 0; i < keys_list_count; i++) {
OSStatus err = noErr;
SecCertificateRef cert = NULL;
SecIdentityRef identity =
* Both hostname check and SNI require SSLSetPeerDomainName().
* Also: the verifyhost setting influences SNI usage */
if(conn_config->verifyhost) {
- char *server = connssl->peer.sni?
- connssl->peer.sni : connssl->peer.hostname;
+ char *server = connssl->peer.sni ?
+ connssl->peer.sni : connssl->peer.hostname;
err = SSLSetPeerDomainName(backend->ssl_ctx, server, strlen(server));
if(err != noErr) {
/* if ssl is expecting something, check if it is available. */
if(connssl->io_need) {
- curl_socket_t writefd = (connssl->io_need & CURL_SSL_IO_NEED_SEND)?
- sockfd:CURL_SOCKET_BAD;
- curl_socket_t readfd = (connssl->io_need & CURL_SSL_IO_NEED_RECV)?
- sockfd:CURL_SOCKET_BAD;
+ curl_socket_t writefd = (connssl->io_need & CURL_SSL_IO_NEED_SEND) ?
+ sockfd : CURL_SOCKET_BAD;
+ curl_socket_t readfd = (connssl->io_need & CURL_SSL_IO_NEED_RECV) ?
+ sockfd : CURL_SOCKET_BAD;
what = Curl_socket_check(readfd, CURL_SOCKET_BAD, writefd,
nonblocking ? 0 : timeout_ms);
if(data->conn) {
struct ssl_primary_config *src, *dest;
#ifndef CURL_DISABLE_PROXY
- src = for_proxy? &data->set.proxy_ssl.primary : &data->set.ssl.primary;
- dest = for_proxy? &data->conn->proxy_ssl_config : &data->conn->ssl_config;
+ src = for_proxy ? &data->set.proxy_ssl.primary : &data->set.ssl.primary;
+ dest = for_proxy ? &data->conn->proxy_ssl_config : &data->conn->ssl_config;
#else
(void)for_proxy;
src = &data->set.ssl.primary;
}
CURL_TRC_CF(data, cf, "%s cached session ID for %s://%s:%d",
- no_match? "No": "Found",
+ no_match ? "No" : "Found",
cf->conn->handler->scheme, peer->hostname, peer->port);
return no_match;
}
if(ci->num_of_certs) {
/* free all individual lists used */
int i;
- for(i = 0; i<ci->num_of_certs; i++) {
+ for(i = 0; i < ci->num_of_certs; i++) {
curl_slist_free_all(ci->certinfo[i]);
ci->certinfo[i] = NULL;
}
default:
break;
}
- return cf->next?
+ return cf->next ?
cf->next->cft->query(cf->next, data, query, pres1, pres2) :
CURLE_UNKNOWN_OPTION;
}
return FALSE;
}
/* ssl backend does not know */
- return cf->next?
+ return cf->next ?
cf->next->cft->is_alive(cf->next, data, input_pending) :
FALSE; /* pessimistic in absence of data */
}
bool Curl_ssl_supports(struct Curl_easy *data, unsigned int ssl_option)
{
(void)data;
- return (Curl_ssl->supports & ssl_option)? TRUE : FALSE;
+ return (Curl_ssl->supports & ssl_option) ? TRUE : FALSE;
}
static struct Curl_cfilter *get_ssl_filter(struct Curl_cfilter *cf)
struct Curl_cfilter *cf, *head;
CURLcode result = CURLE_OK;
- head = data->conn? data->conn->cfilter[sockindex] : NULL;
+ head = data->conn ? data->conn->cfilter[sockindex] : NULL;
for(cf = head; cf; cf = cf->next) {
if(cf->cft == &Curl_cft_ssl) {
bool done;
(void)cf;
return &data->set.ssl;
#else
- return Curl_ssl_cf_is_proxy(cf)? &data->set.proxy_ssl : &data->set.ssl;
+ return Curl_ssl_cf_is_proxy(cf) ? &data->set.proxy_ssl : &data->set.ssl;
#endif
}
#ifdef CURL_DISABLE_PROXY
return &cf->conn->ssl_config;
#else
- return Curl_ssl_cf_is_proxy(cf)?
+ return Curl_ssl_cf_is_proxy(cf) ?
&cf->conn->proxy_ssl_config : &cf->conn->ssl_config;
#endif
}
{
unsigned char *palpn =
#ifndef CURL_DISABLE_PROXY
- (cf->conn->bits.tunnel_proxy && Curl_ssl_cf_is_proxy(cf))?
+ (cf->conn->bits.tunnel_proxy && Curl_ssl_cf_is_proxy(cf)) ?
&cf->conn->proxy_alpn : &cf->conn->alpn
#else
&cf->conn->alpn
/* load trusted cacert from file if not blob */
CURL_TRC_CF(data, cf, "populate_x509_store, path=%s, blob=%d",
- ssl_cafile? ssl_cafile : "none", !!ca_info_blob);
+ ssl_cafile ? ssl_cafile : "none", !!ca_info_blob);
if(!store)
return CURLE_OUT_OF_MEMORY;
WOLFSSL_X509_STORE *store = NULL;
DEBUGASSERT(multi);
- share = multi? Curl_hash_pick(&multi->proto_hash,
- (void *)MPROTO_WSSL_X509_KEY,
- sizeof(MPROTO_WSSL_X509_KEY)-1) : NULL;
+ share = multi ? Curl_hash_pick(&multi->proto_hash,
+ (void *)MPROTO_WSSL_X509_KEY,
+ sizeof(MPROTO_WSSL_X509_KEY)-1) : NULL;
if(share && share->store &&
!cached_x509_store_expired(data, share) &&
!cached_x509_store_different(cf, share)) {
* anyway. In the latter case the result of the verification is checked with
* SSL_get_verify_result() below. */
wolfSSL_CTX_set_verify(backend->ctx,
- conn_config->verifypeer?SSL_VERIFY_PEER:
+ conn_config->verifypeer ? SSL_VERIFY_PEER :
SSL_VERIFY_NONE, NULL);
#ifdef HAVE_SNI
(struct wolfssl_ctx *)connssl->backend;
struct ssl_primary_config *conn_config = Curl_ssl_cf_get_primary_config(cf);
#ifndef CURL_DISABLE_PROXY
- const char * const pinnedpubkey = Curl_ssl_cf_is_proxy(cf)?
- data->set.str[STRING_SSL_PINNEDPUBLICKEY_PROXY]:
+ const char * const pinnedpubkey = Curl_ssl_cf_is_proxy(cf) ?
+ data->set.str[STRING_SSL_PINNEDPUBLICKEY_PROXY] :
data->set.str[STRING_SSL_PINNEDPUBLICKEY];
#else
const char * const pinnedpubkey = data->set.str[STRING_SSL_PINNEDPUBLICKEY];
/* Enable RFC2818 checks */
if(conn_config->verifyhost) {
- char *snihost = connssl->peer.sni?
- connssl->peer.sni : connssl->peer.hostname;
+ char *snihost = connssl->peer.sni ?
+ connssl->peer.sni : connssl->peer.hostname;
if(wolfSSL_check_domain_name(backend->handle, snihost) == SSL_FAILURE)
return CURLE_SSL_CONNECT_ERROR;
}
CURLcode result;
struct ssl_connect_data *connssl = cf->ctx;
curl_socket_t sockfd = Curl_conn_cf_get_socket(cf, data);
- int what;
/* check if the connection has already been established */
if(ssl_connection_complete == connssl->state) {
/* if ssl is expecting something, check if it is available. */
if(connssl->io_need) {
-
- curl_socket_t writefd = (connssl->io_need & CURL_SSL_IO_NEED_SEND)?
- sockfd:CURL_SOCKET_BAD;
- curl_socket_t readfd = (connssl->io_need & CURL_SSL_IO_NEED_RECV)?
- sockfd:CURL_SOCKET_BAD;
-
- what = Curl_socket_check(readfd, CURL_SOCKET_BAD, writefd,
- nonblocking?0:timeout_ms);
+ curl_socket_t writefd = (connssl->io_need & CURL_SSL_IO_NEED_SEND) ?
+ sockfd : CURL_SOCKET_BAD;
+ curl_socket_t readfd = (connssl->io_need & CURL_SSL_IO_NEED_RECV) ?
+ sockfd : CURL_SOCKET_BAD;
+ int what = Curl_socket_check(readfd, CURL_SOCKET_BAD, writefd,
+ nonblocking ? 0 : timeout_ms);
if(what < 0) {
/* fatal error */
failf(data, "select/poll on SSL socket, errno: %d", SOCKERRNO);
{
if(end - beg != 1)
return CURLE_BAD_FUNCTION_ARGUMENT;
- return Curl_dyn_add(store, *beg? "TRUE": "FALSE");
+ return Curl_dyn_add(store, *beg ? "TRUE": "FALSE");
}
/*
do
val = (val << 8) | *(const unsigned char *) beg++;
while(beg < end);
- return Curl_dyn_addf(store, "%s%x", val >= 10? "0x": "", val);
+ return Curl_dyn_addf(store, "%s%x", val >= 10 ? "0x" : "", val);
}
/*
"%.4s-%.2s-%.2s %.2s:%.2s:%c%c%s%.*s%s%.*s",
beg, beg + 4, beg + 6,
beg + 8, beg + 10, sec1, sec2,
- fracl? ".": "", (int)fracl, fracp,
+ fracl ? ".": "", (int)fracl, fracp,
sep, (int)tzl, tzp);
}
case 1:
CURL_TRC_WRITE(data, "websocket, decoded %s [%s%s]", msg,
ws_frame_name_of_op(dec->head[0]),
- (dec->head[0] & WSBIT_FIN)? "" : " NON-FINAL");
+ (dec->head[0] & WSBIT_FIN) ? "" : " NON-FINAL");
break;
default:
if(dec->head_len < dec->head_total) {
CURL_TRC_WRITE(data, "websocket, decoded %s [%s%s](%d/%d)", msg,
ws_frame_name_of_op(dec->head[0]),
- (dec->head[0] & WSBIT_FIN)? "" : " NON-FINAL",
+ (dec->head[0] & WSBIT_FIN) ? "" : " NON-FINAL",
dec->head_len, dec->head_total);
}
else {
CURL_TRC_WRITE(data, "websocket, decoded %s [%s%s payload=%"
FMT_OFF_T "/%" FMT_OFF_T "]",
msg, ws_frame_name_of_op(dec->head[0]),
- (dec->head[0] & WSBIT_FIN)? "" : " NON-FINAL",
+ (dec->head[0] & WSBIT_FIN) ? "" : " NON-FINAL",
dec->payload_offset, dec->payload_len);
}
break;
FMT_OFF_T " remain", nwritten, remain);
}
- return remain? CURLE_AGAIN : CURLE_OK;
+ return remain ? CURLE_AGAIN : CURLE_OK;
}
static CURLcode ws_dec_pass(struct ws_decoder *dec,
msg, ws_frame_name_of_op(enc->firstbyte),
(enc->firstbyte & WSBIT_OPCODE_MASK) == WSBIT_OPCODE_CONT ?
" CONT" : "",
- (enc->firstbyte & WSBIT_FIN)? "" : " NON-FIN",
+ (enc->firstbyte & WSBIT_FIN) ? "" : " NON-FIN",
enc->payload_len - enc->payload_remain, enc->payload_len);
}
while(Curl_bufq_peek(&ws->sendbuf, &out, &outlen)) {
if(blocking) {
result = ws_send_raw_blocking(data, ws, (char *)out, outlen);
- n = result? 0 : outlen;
+ n = result ? 0 : outlen;
}
else if(data->set.connect_only || Curl_is_in_callback(data))
result = Curl_senddata(data, out, outlen, &n);
if(sock == CURL_SOCKET_BAD)
return CURLE_SEND_ERROR;
ev = Curl_socket_check(CURL_SOCKET_BAD, CURL_SOCKET_BAD, sock,
- left_ms? left_ms : 500);
+ left_ms ? left_ms : 500);
if(ev < 0) {
failf(data, "Error while waiting for socket becoming writable");
return CURLE_SEND_ERROR;
dccsid = ASCII_CCSID;
if(sccsid == dccsid) {
- lslen = slen >= 0? slen: strlen(s) + 1;
- i = lslen < dlen? lslen: dlen;
+ lslen = slen >= 0 ? slen: strlen(s) + 1;
+ i = lslen < dlen ? lslen: dlen;
if(s != d && i > 0)
memcpy(d, s, i);
/* Like convert, but the destination is allocated and returned. */
- dlen = (size_t) (slen < 0? strlen(s): slen) + 1;
+ dlen = (size_t) (slen < 0 ? strlen(s): slen) + 1;
dlen *= MAX_CONV_EXPANSION; /* Allow some expansion. */
d = malloc(dlen);
return (char *) NULL;
}
- s = dynconvert(ASCII_CCSID, string, length? length: -1, sccsid);
+ s = dynconvert(ASCII_CCSID, string, length ? length: -1, sccsid);
if(!s)
return (char *) NULL;
return (char *) NULL;
}
- s = dynconvert(ASCII_CCSID, string, length? length: -1, sccsid);
+ s = dynconvert(ASCII_CCSID, string, length ? length: -1, sccsid);
if(!s)
return (char *) NULL;
ret = (*p->append)(p->arg, b, l);
free(b);
- return ret == l? len: -1;
+ return ret == l ? len: -1;
}
}
if(status == LDAP_SUCCESS)
- status = ldap_search_s(ld, ebase? ebase: "", scope,
- efilter? efilter: "(objectclass=*)",
+ status = ldap_search_s(ld, ebase ? ebase: "", scope,
+ efilter ? efilter: "(objectclass=*)",
eattrs, attrsonly, res);
if(eattrs) {
}
}
if(!match) {
- if(!nulls || (nulls>10)) {
+ if(!nulls || (nulls > 10)) {
printf("\n ");
nulls = 0;
}
if(bar->tick >= 200)
bar->tick -= 200;
- bar->bar += (moved?bar->barmove:0);
+ bar->bar += (moved ? bar->barmove : 0);
if(bar->bar >= (bar->width - 6)) {
bar->barmove = -1;
bar->bar = bar->width - 6;
tool_go_sleep(25);
}
- return per->noprogress? 0 : CURL_PROGRESSFUNC_CONTINUE;
+ return per->noprogress ? 0 : CURL_PROGRESSFUNC_CONTINUE;
}
case C_HEAD: /* --head */
config->no_body = toggle;
config->show_headers = toggle;
- if(SetHTTPrequest(config,
- (config->no_body)?TOOL_HTTPREQ_HEAD:TOOL_HTTPREQ_GET,
- &config->httpreq))
+ if(SetHTTPrequest(config, (config->no_body) ? TOOL_HTTPREQ_HEAD :
+ TOOL_HTTPREQ_GET, &config->httpreq))
err = PARAM_BAD_USE;
break;
case C_REMOTE_HEADER_NAME: /* --remote-header-name */
config->nobuffer = longopt ? !toggle : TRUE;
break;
case C_REMOTE_NAME_ALL: /* --remote-name-all */
- config->default_node_flags = toggle?GETOUT_USEREMOTE:0;
+ config->default_node_flags = toggle ? GETOUT_USEREMOTE : 0;
break;
case C_OUTPUT_DIR: /* --output-dir */
err = getstr(&config->output_dir, nextarg, DENY_BLANK);
curl_url_cleanup(uh);
}
- *scheme = (char *) (proto? proto: "???"); /* Never match if not found. */
+ *scheme = (char *) (proto ? proto : "???"); /* Never match if not found. */
return result;
}
/* Use the postfields data for an HTTP get */
httpgetfields = state->httpgetfields = config->postfields;
config->postfields = NULL;
- if(SetHTTPrequest(config,
- (config->no_body?TOOL_HTTPREQ_HEAD:TOOL_HTTPREQ_GET),
- &config->httpreq)) {
+ if(SetHTTPrequest(config, (config->no_body ? TOOL_HTTPREQ_HEAD :
+ TOOL_HTTPREQ_GET), &config->httpreq)) {
result = CURLE_FAILED_INIT;
}
}
if(!config->globoff && infiles && !inglob) {
/* Unless explicitly shut off */
result = glob_url(&inglob, infiles, &state->infilenum,
- (!global->silent || global->showerror)?
- tool_stderr:NULL);
+ (!global->silent || global->showerror) ?
+ tool_stderr : NULL);
if(result)
break;
config->state.inglob = inglob;
/* Unless explicitly shut off, we expand '{...}' and '[...]'
expressions and return total number of URLs in pattern set */
result = glob_url(&state->urls, urlnode->url, &state->urlnum,
- (!global->silent || global->showerror)?
- tool_stderr:NULL);
+ (!global->silent || global->showerror) ?
+ tool_stderr : NULL);
if(result)
break;
urlnum = state->urlnum;
* If the user has also selected --anyauth or --proxy-anyauth
* we should warn them.
*/
- if(config->proxyanyauth || (authbits>1)) {
+ if(config->proxyanyauth || (authbits > 1)) {
warnf(global,
"Using --anyauth or --proxy-anyauth with upload from stdin"
" involves a big risk of it not working. Use a temporary"
my_setopt_str(curl, CURLOPT_URL, per->this_url);
my_setopt(curl, CURLOPT_NOPROGRESS,
- global->noprogress || global->silent?1L:0L);
+ global->noprogress || global->silent ? 1L : 0L);
if(config->no_body)
my_setopt(curl, CURLOPT_NOBODY, 1L);
my_setopt_str(curl, CURLOPT_PROXYUSERPWD, config->proxyuserpwd);
/* new in libcurl 7.3 */
- my_setopt(curl, CURLOPT_HTTPPROXYTUNNEL, config->proxytunnel?1L:0L);
+ my_setopt(curl, CURLOPT_HTTPPROXYTUNNEL, config->proxytunnel ?
+ 1L : 0L);
/* new in libcurl 7.52.0 */
if(config->preproxy)
my_setopt_str(curl, CURLOPT_NOPROXY, config->noproxy);
my_setopt(curl, CURLOPT_SUPPRESS_CONNECT_HEADERS,
- config->suppress_connect_headers?1L:0L);
+ config->suppress_connect_headers ? 1L : 0L);
- my_setopt(curl, CURLOPT_FAILONERROR, config->failonerror?1L:0L);
+ my_setopt(curl, CURLOPT_FAILONERROR, config->failonerror ? 1L : 0L);
my_setopt(curl, CURLOPT_REQUEST_TARGET, config->request_target);
- my_setopt(curl, CURLOPT_UPLOAD, per->uploadfile?1L:0L);
- my_setopt(curl, CURLOPT_DIRLISTONLY, config->dirlistonly?1L:0L);
- my_setopt(curl, CURLOPT_APPEND, config->ftp_append?1L:0L);
+ my_setopt(curl, CURLOPT_UPLOAD, per->uploadfile ? 1L : 0L);
+ my_setopt(curl, CURLOPT_DIRLISTONLY, config->dirlistonly ? 1L : 0L);
+ my_setopt(curl, CURLOPT_APPEND, config->ftp_append ? 1L : 0L);
if(config->netrc_opt)
my_setopt_enum(curl, CURLOPT_NETRC, (long)CURL_NETRC_OPTIONAL);
if(config->netrc_file)
my_setopt_str(curl, CURLOPT_NETRC_FILE, config->netrc_file);
- my_setopt(curl, CURLOPT_TRANSFERTEXT, config->use_ascii?1L:0L);
+ my_setopt(curl, CURLOPT_TRANSFERTEXT, config->use_ascii ? 1L : 0L);
if(config->login_options)
my_setopt_str(curl, CURLOPT_LOGIN_OPTIONS, config->login_options);
my_setopt_str(curl, CURLOPT_USERPWD, config->userpwd);
long postRedir = 0;
my_setopt(curl, CURLOPT_FOLLOWLOCATION,
- config->followlocation?1L:0L);
+ config->followlocation ? 1L : 0L);
my_setopt(curl, CURLOPT_UNRESTRICTED_AUTH,
- config->unrestricted_auth?1L:0L);
+ config->unrestricted_auth ? 1L : 0L);
my_setopt_str(curl, CURLOPT_AWS_SIGV4, config->aws_sigv4);
- my_setopt(curl, CURLOPT_AUTOREFERER, config->autoreferer?1L:0L);
+ my_setopt(curl, CURLOPT_AUTOREFERER, config->autoreferer ? 1L : 0L);
/* new in libcurl 7.36.0 */
if(config->proxyheaders) {
my_setopt(curl, CURLOPT_FILETIME, 1L);
}
- my_setopt(curl, CURLOPT_CRLF, config->crlf?1L:0L);
+ my_setopt(curl, CURLOPT_CRLF, config->crlf ? 1L : 0L);
my_setopt_slist(curl, CURLOPT_QUOTE, config->quote);
my_setopt_slist(curl, CURLOPT_POSTQUOTE, config->postquote);
my_setopt_slist(curl, CURLOPT_PREQUOTE, config->prequote);
my_setopt_str(curl, CURLOPT_COOKIEJAR, config->cookiejar);
/* new in libcurl 7.9.7 */
- my_setopt(curl, CURLOPT_COOKIESESSION, config->cookiesession?1L:0L);
+ my_setopt(curl, CURLOPT_COOKIESESSION, config->cookiesession ?
+ 1L : 0L);
my_setopt_enum(curl, CURLOPT_TIMECONDITION, (long)config->timecond);
my_setopt(curl, CURLOPT_TIMEVALUE_LARGE, config->condtime);
/* new in curl 7.10.7, extended in 7.19.4. Modified to use
CREATE_DIR_RETRY in 7.49.0 */
my_setopt(curl, CURLOPT_FTP_CREATE_MISSING_DIRS,
- (long)(config->ftp_create_dirs?
- CURLFTP_CREATE_DIR_RETRY:
- CURLFTP_CREATE_DIR_NONE));
+ (long)(config->ftp_create_dirs ?
+ CURLFTP_CREATE_DIR_RETRY : CURLFTP_CREATE_DIR_NONE));
/* new in curl 7.10.8 */
if(config->max_filesize)
/* curl 7.13.0 */
my_setopt_str(curl, CURLOPT_FTP_ACCOUNT, config->ftp_account);
- my_setopt(curl, CURLOPT_IGNORE_CONTENT_LENGTH, config->ignorecl?1L:0L);
+ my_setopt(curl, CURLOPT_IGNORE_CONTENT_LENGTH, config->ignorecl ?
+ 1L : 0L);
/* curl 7.14.2 */
- my_setopt(curl, CURLOPT_FTP_SKIP_PASV_IP, config->ftp_skip_ip?1L:0L);
+ my_setopt(curl, CURLOPT_FTP_SKIP_PASV_IP, config->ftp_skip_ip ?
+ 1L : 0L);
/* curl 7.15.1 */
if(proto_ftp)
unsigned long i;
num--; /* make it zero based */
/* find the correct glob entry */
- for(i = 0; i<glob->size; i++) {
+ for(i = 0; i < glob->size; i++) {
if(glob->pattern[i].globindex == (int)num) {
pat = &glob->pattern[i];
break;
int struplocompare(const char *p1, const char *p2)
{
if(!p1)
- return p2? -1: 0;
+ return p2 ? -1 : 0;
if(!p2)
return 1;
#ifdef HAVE_STRCASECMP
FILE *stream2;
memcpy(fname, ptr, flen);
fname[flen] = 0;
- stream2 = fopen(fname, append? FOPEN_APPENDTEXT :
+ stream2 = fopen(fname, append ? FOPEN_APPENDTEXT :
FOPEN_WRITETEXT);
if(stream2) {
/* only change if the open worked */
if(p) {
memcpy(p->name, name, nlen);
- p->content = contalloc ? content: Memdup(content, clen);
+ p->content = contalloc ? content : Memdup(content, clen);
if(p->content) {
p->clen = clen;
host, port);
resolve = curl_slist_append(resolve, resolve_buf);
- for(i = 0; i<HANDLECOUNT; i++) {
+ for(i = 0; i < HANDLECOUNT; i++) {
handles[i].idx = i;
handles[i].paused = 0;
handles[i].resumed = 0;
if(!multi_handle)
err();
- for(i = 0; i<HANDLECOUNT; i++) {
+ for(i = 0; i < HANDLECOUNT; i++) {
if(curl_multi_add_handle(multi_handle, handles[i].h) != CURLM_OK)
err();
}
if(!still_running) {
int as_expected = 1;
fprintf(stderr, "INFO: no more handles running\n");
- for(i = 0; i<HANDLECOUNT; i++) {
+ for(i = 0; i < HANDLECOUNT; i++) {
if(!handles[i].paused) {
fprintf(stderr, "ERROR: [%d] NOT PAUSED\n", i);
as_expected = 0;
/* !checksrc! disable EQUALSNULL 1 */
while((msg = curl_multi_info_read(multi_handle, &msgs_left)) != NULL) {
if(msg->msg == CURLMSG_DONE) {
- for(i = 0; i<HANDLECOUNT; i++) {
+ for(i = 0; i < HANDLECOUNT; i++) {
if(msg->easy_handle == handles[i].h) {
if(handles[i].paused != 1 || !handles[i].resumed) {
fprintf(stderr, "ERROR: [%d] done, pauses=%d, resumed=%d, "
/* Successfully paused? */
if(!all_paused) {
- for(i = 0; i<HANDLECOUNT; i++) {
+ for(i = 0; i < HANDLECOUNT; i++) {
if(!handles[i].paused) {
break;
}
}
if(resume_round > 0 && rounds == resume_round) {
/* time to resume */
- for(i = 0; i<HANDLECOUNT; i++) {
+ for(i = 0; i < HANDLECOUNT; i++) {
fprintf(stderr, "INFO: [%d] resumed\n", i);
handles[i].resumed = 1;
curl_easy_pause(handles[i].h, CURLPAUSE_CONT);
}
out:
- for(i = 0; i<HANDLECOUNT; i++) {
+ for(i = 0; i < HANDLECOUNT; i++) {
curl_multi_remove_handle(multi_handle, handles[i].h);
curl_easy_cleanup(handles[i].h);
}
fprintf(stderr, "%s, %lu bytes (0x%lx)\n",
text, (unsigned long)size, (unsigned long)size);
- for(i = 0; i<size; i += width) {
+ for(i = 0; i < size; i += width) {
fprintf(stderr, "%4.4lx: ", (unsigned long)i);
break;
}
fprintf(stderr, "%c",
- (ptr[i + c] >= 0x20) && (ptr[i + c]<0x80)?ptr[i + c]:'.');
+ (ptr[i + c] >= 0x20) && (ptr[i + c] < 0x80) ? ptr[i + c] : '.');
/* check again for 0D0A, to avoid an extra \n if it's at width */
if(nohex && (i + c + 2 < size) && ptr[i + c + 1] == 0x0D &&
ptr[i + c + 2] == 0x0A) {
fprintf(stderr, "**** push callback approves stream %u, got %lu headers!\n",
count, (unsigned long)num_headers);
- for(i = 0; i<num_headers; i++) {
+ for(i = 0; i < num_headers; i++) {
headp = curl_pushheader_bynum(headers, i);
fprintf(stderr, "**** header %lu: %s\n", (unsigned long)i, headp);
}
t->pause_at = (curl_off_t)pause_offset;
}
- n = (max_parallel < transfer_count)? max_parallel : transfer_count;
+ n = (max_parallel < transfer_count) ? max_parallel : transfer_count;
for(i = 0; i < n; ++i) {
t = &transfers[i];
t->easy = curl_easy_init();
multi_handle = curl_multi_init();
curl_multi_setopt(multi_handle, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
- n = (max_parallel < transfer_count)? max_parallel : transfer_count;
+ n = (max_parallel < transfer_count) ? max_parallel : transfer_count;
for(i = 0; i < n; ++i) {
t = &transfers[i];
t->easy = curl_easy_init();
fprintf(stderr, "%s, %lu bytes (0x%lx)\n",
text, (unsigned long)size, (unsigned long)size);
- for(i = 0; i<size; i += width) {
+ for(i = 0; i < size; i += width) {
fprintf(stderr, "%4.4lx: ", (unsigned long)i);
break;
}
fprintf(stderr, "%c",
- (ptr[i + c] >= 0x20) && (ptr[i + c]<0x80)?ptr[i + c]:'.');
+ (ptr[i + c] >= 0x20) && (ptr[i + c] < 0x80) ? ptr[i + c] : '.');
/* check again for 0D0A, to avoid an extra \n if it's at width */
if(nohex && (i + c + 2 < size) && ptr[i + c + 1] == 0x0D &&
ptr[i + c + 2] == 0x0A) {
ap_log_rerror(APLOG_MARK, APLOG_TRACE1, 0, r, "error_handler: processing "
"request, %s", r->args? r->args : "(no args)");
r->status = http_status;
- r->clength = with_cl? (chunks * chunk_size) : -1;
+ r->clength = with_cl ? (chunks * chunk_size) : -1;
r->chunked = (r->proto_num >= HTTP_VERSION(1, 1)) && !with_cl;
apr_table_setn(r->headers_out, "request-id", request_id);
if(r->clength >= 0) {
size_t i;
if(len > 200)
return NULL;
- for(i = 0; i<len; i++, p += 3)
+ for(i = 0; i < len; i++, p += 3)
msnprintf(p, 4, "%02x ", buffer[i]);
return dump;
}
setlocale(LC_ALL, "");
#endif
- if(argc< 2) {
+ if(argc < 2) {
fprintf(stderr, "Pass URL as argument please\n");
return 1;
}
test_argc = argc;
test_argv = argv;
- if(argc>2)
+ if(argc > 2)
libtest_arg2 = argv[2];
- if(argc>3)
+ if(argc > 3)
libtest_arg3 = argv[3];
URL = argv[1]; /* provide this to the rest */
unsigned int replyselector;
char urlbuf[256];
- replyselector = (p->flags & F_CONTENTRANGE)? 1: 0;
+ replyselector = (p->flags & F_CONTENTRANGE) ? 1: 0;
if(p->flags & F_HTTP416)
replyselector += 2;
msnprintf(urlbuf, sizeof(urlbuf), "%s%04u", url, replyselector);
test_setopt(curl, CURLOPT_URL, urlbuf);
test_setopt(curl, CURLOPT_VERBOSE, 1L);
- test_setopt(curl, CURLOPT_RESUME_FROM, (p->flags & F_RESUME)? 3: 0);
- test_setopt(curl, CURLOPT_RANGE, !(p->flags & F_RESUME)?
+ test_setopt(curl, CURLOPT_RESUME_FROM, (p->flags & F_RESUME) ? 3: 0);
+ test_setopt(curl, CURLOPT_RANGE, !(p->flags & F_RESUME) ?
"3-1000000": (char *) NULL);
- test_setopt(curl, CURLOPT_FAILONERROR, (p->flags & F_FAIL)? 1: 0);
+ test_setopt(curl, CURLOPT_FAILONERROR, (p->flags & F_FAIL) ? 1: 0);
hasbody = 0;
res = curl_easy_perform(curl);
if(res != p->result) {
printf("%zd: bad error code (%d): resume=%s, fail=%s, http416=%s, "
"content-range=%s, expected=%d\n", num, res,
- (p->flags & F_RESUME)? "yes": "no",
- (p->flags & F_FAIL)? "yes": "no",
- (p->flags & F_HTTP416)? "yes": "no",
- (p->flags & F_CONTENTRANGE)? "yes": "no",
+ (p->flags & F_RESUME) ? "yes": "no",
+ (p->flags & F_FAIL) ? "yes": "no",
+ (p->flags & F_HTTP416) ? "yes": "no",
+ (p->flags & F_CONTENTRANGE) ? "yes": "no",
p->result);
return 1;
}
if(hasbody && (p->flags & F_IGNOREBODY)) {
printf("body should be ignored and is not: resume=%s, fail=%s, "
"http416=%s, content-range=%s\n",
- (p->flags & F_RESUME)? "yes": "no",
- (p->flags & F_FAIL)? "yes": "no",
- (p->flags & F_HTTP416)? "yes": "no",
- (p->flags & F_CONTENTRANGE)? "yes": "no");
+ (p->flags & F_RESUME) ? "yes": "no",
+ (p->flags & F_FAIL) ? "yes": "no",
+ (p->flags & F_HTTP416) ? "yes": "no",
+ (p->flags & F_CONTENTRANGE) ? "yes": "no");
return 1;
}
return 0;
char *partp;
msnprintf(total, sizeof(total),
"%s://%s:%s@%s/%s?%s#%s",
- (i == 0)? &bigpart[1] : smallpart,
- (i == 1)? &bigpart[1] : smallpart,
- (i == 2)? &bigpart[1] : smallpart,
- (i == 3)? &bigpart[1] : smallpart,
- (i == 4)? &bigpart[1] : smallpart,
- (i == 5)? &bigpart[1] : smallpart,
- (i == 6)? &bigpart[1] : smallpart);
+ (i == 0) ? &bigpart[1] : smallpart,
+ (i == 1) ? &bigpart[1] : smallpart,
+ (i == 2) ? &bigpart[1] : smallpart,
+ (i == 3) ? &bigpart[1] : smallpart,
+ (i == 4) ? &bigpart[1] : smallpart,
+ (i == 5) ? &bigpart[1] : smallpart,
+ (i == 6) ? &bigpart[1] : smallpart);
rc = curl_url_set(urlp, CURLUPART_URL, total, CURLU_NON_SUPPORT_SCHEME);
if((!i && (rc != CURLUE_BAD_SCHEME)) ||
(i && rc)) {
if(wd->nwrites > 0)
flush_data(wd);
wd->has_meta = (meta != NULL);
- wd->meta_flags = meta? meta->flags : 0;
+ wd->meta_flags = meta ? meta->flags : 0;
}
if(wd->blen + blen > sizeof(wd->buf)) {
fprintf(stream, "%s, %zu bytes (0x%zx)\n", text, size, size);
- for(i = 0; i<size; i += width) {
+ for(i = 0; i < size; i += width) {
fprintf(stream, "%04zx: ", i);
break;
}
fprintf(stream, "%c",
- (ptr[i + c] >= 0x20) && (ptr[i + c]<0x80)? ptr[i + c] : '.');
+ (ptr[i + c] >= 0x20) && (ptr[i + c] < 0x80) ? ptr[i + c] : '.');
/* check again for 0D0A, to avoid an extra \n if it's at width */
if(nohex && (i + c + 2 < size) && ptr[i + c + 1] == 0x0D &&
ptr[i + c + 2] == 0x0A) {
for(i = 1; i <= num_ushort_tests; i++) {
- for(j = 0; j<BUFSZ; j++)
+ for(j = 0; j < BUFSZ; j++)
us_test[i].result[j] = 'X';
us_test[i].result[BUFSZ-1] = '\0';
for(i = 1; i <= num_sshort_tests; i++) {
- for(j = 0; j<BUFSZ; j++)
+ for(j = 0; j < BUFSZ; j++)
ss_test[i].result[j] = 'X';
ss_test[i].result[BUFSZ-1] = '\0';
for(i = 1; i <= num_uint_tests; i++) {
- for(j = 0; j<BUFSZ; j++)
+ for(j = 0; j < BUFSZ; j++)
ui_test[i].result[j] = 'X';
ui_test[i].result[BUFSZ-1] = '\0';
for(i = 1; i <= num_sint_tests; i++) {
- for(j = 0; j<BUFSZ; j++)
+ for(j = 0; j < BUFSZ; j++)
si_test[i].result[j] = 'X';
si_test[i].result[BUFSZ-1] = '\0';
for(i = 1; i <= num_ulong_tests; i++) {
- for(j = 0; j<BUFSZ; j++)
+ for(j = 0; j < BUFSZ; j++)
ul_test[i].result[j] = 'X';
ul_test[i].result[BUFSZ-1] = '\0';
for(i = 1; i <= num_slong_tests; i++) {
- for(j = 0; j<BUFSZ; j++)
+ for(j = 0; j < BUFSZ; j++)
sl_test[i].result[j] = 'X';
sl_test[i].result[BUFSZ-1] = '\0';
for(i = 1; i <= num_cofft_tests; i++) {
- for(j = 0; j<BUFSZ; j++)
+ for(j = 0; j < BUFSZ; j++)
co_test[i].result[j] = 'X';
co_test[i].result[BUFSZ-1] = '\0';
/* very large precisions easily turn into system specific outputs so we only
check the output buffer length here as we know the internal limit */
- curl_msnprintf(buf, sizeof(buf), "%.*f", (1<<30), 9.2987654);
+ curl_msnprintf(buf, sizeof(buf), "%.*f", (1 << 30), 9.2987654);
errors += strlen_check(buf, 325);
curl_msnprintf(buf, sizeof(buf), "%10000.10000f", 9.2987654);
/* curl_msnprintf() limits a single float output to 325 bytes maximum
width */
- curl_msnprintf(buf, sizeof(buf), "%*f", (1<<30), 9.1);
+ curl_msnprintf(buf, sizeof(buf), "%*f", (1 << 30), 9.1);
errors += string_check(buf, " 9.100000");
curl_msnprintf(buf, sizeof(buf), "%100000f", 9.1);
errors += string_check(buf, " 9.100000");
return CURL_READFUNC_PAUSE;
case 2:
delta = time(NULL) - pooh->origin;
- *ptr = delta >= PAUSE_TIME? '\x42': '\x41'; /* ASCII A or B. */
+ *ptr = delta >= PAUSE_TIME ? '\x42': '\x41'; /* ASCII A or B. */
return 1;
case 3:
return 0;
ssize_t width = 0;
int left = sizeof(data);
- for(i = 0; i<len && (left >= 0); i++) {
+ for(i = 0; i < len && (left >= 0); i++) {
msnprintf(optr, left, "%02x", ptr[i]);
width += 2;
optr += 2;
char *optr = data;
int left = sizeof(data);
- for(i = 0; i<len && (left >= 0); i++) {
+ for(i = 0; i < len && (left >= 0); i++) {
msnprintf(optr, left, "%02x", ptr[i]);
optr += 2;
left -= 2;
}
fprintf(output, "%s %s %zx %s\n",
- dir == FROM_CLIENT? "client": "server",
- prefix, remlen,
- data);
+ dir == FROM_CLIENT ? "client" : "server",
+ prefix, remlen, data);
}
int error;
int arg = 1;
- while(argc>arg) {
+ while(argc > arg) {
if(!strcmp("--version", argv[arg])) {
printf("mqttd IPv4%s\n",
#ifdef USE_IPV6
}
else if(!strcmp("--pidfile", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
pidname = argv[arg++];
}
else if(!strcmp("--portfile", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
portname = argv[arg++];
}
else if(!strcmp("--config", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
configfile = argv[arg++];
}
else if(!strcmp("--logfile", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
serverlogfile = argv[arg++];
}
else if(!strcmp("--logdir", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
logdir = argv[arg++];
}
else if(!strcmp("--ipv6", argv[arg])) {
}
else if(!strcmp("--port", argv[arg])) {
arg++;
- if(argc>arg) {
+ if(argc > arg) {
char *endptr;
unsigned long ulnum = strtoul(argv[arg], &endptr, 10);
if((endptr != argv[arg] + strlen(argv[arg])) ||
const char *host = NULL;
int rc = 0;
- while(argc>arg) {
+ while(argc > arg) {
if(!strcmp("--version", argv[arg])) {
printf("resolve IPv4%s\n",
#if defined(CURLRES_IPV6)
count -= written;
buffer += written;
- } while(count>0);
+ } while(count > 0);
/* Send out any RTP data */
if(req->rtp_buffer) {
memset(&req, 0, sizeof(req));
- while(argc>arg) {
+ while(argc > arg) {
if(!strcmp("--version", argv[arg])) {
printf("rtspd IPv4%s"
"\n"
}
else if(!strcmp("--pidfile", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
pidname = argv[arg++];
}
else if(!strcmp("--portfile", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
portname = argv[arg++];
}
else if(!strcmp("--logfile", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
serverlogfile = argv[arg++];
}
else if(!strcmp("--logdir", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
logdir = argv[arg++];
}
else if(!strcmp("--ipv4", argv[arg])) {
}
else if(!strcmp("--port", argv[arg])) {
arg++;
- if(argc>arg) {
+ if(argc > arg) {
char *endptr;
unsigned long ulnum = strtoul(argv[arg], &endptr, 10);
port = curlx_ultous(ulnum);
}
else if(!strcmp("--srcdir", argv[arg])) {
arg++;
- if(argc>arg) {
+ if(argc > arg) {
path = argv[arg];
arg++;
}
ssize_t width = 0;
int left = sizeof(data);
- for(i = 0; i<len; i++) {
+ for(i = 0; i < len; i++) {
switch(ptr[i]) {
case '\n':
msnprintf(optr, left, "\\n");
break;
default:
msnprintf(optr, left, "%c", (ISGRAPH(ptr[i]) ||
- ptr[i] == 0x20) ?ptr[i]:'.');
+ ptr[i] == 0x20) ? ptr[i] : '.');
width++;
optr++;
left--;
break;
}
- if(width>60) {
+ if(width > 60) {
logmsg("'%s'", data);
width = 0;
optr = data;
enum sockmode mode = PASSIVE_LISTEN; /* default */
const char *addr = NULL;
- while(argc>arg) {
+ while(argc > arg) {
if(!strcmp("--version", argv[arg])) {
printf("sockfilt IPv4%s\n",
#ifdef USE_IPV6
}
else if(!strcmp("--pidfile", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
pidname = argv[arg++];
}
else if(!strcmp("--portfile", argv[arg])) {
}
else if(!strcmp("--logfile", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
serverlogfile = argv[arg++];
}
else if(!strcmp("--ipv6", argv[arg])) {
}
else if(!strcmp("--port", argv[arg])) {
arg++;
- if(argc>arg) {
+ if(argc > arg) {
char *endptr;
unsigned long ulnum = strtoul(argv[arg], &endptr, 10);
port = curlx_ultous(ulnum);
/* Asked to actively connect to the specified local port instead of
doing a passive server-style listening. */
arg++;
- if(argc>arg) {
+ if(argc > arg) {
char *endptr;
unsigned long ulnum = strtoul(argv[arg], &endptr, 10);
if((endptr != argv[arg] + strlen(argv[arg])) ||
else if(!strcmp("--addr", argv[arg])) {
/* Set an IP address to use with --connect; otherwise use localhost */
arg++;
- if(argc>arg) {
+ if(argc > arg) {
addr = argv[arg];
arg++;
}
ssize_t width = 0;
int left = sizeof(data);
- for(i = 0; i<len && (left >= 0); i++) {
+ for(i = 0; i < len && (left >= 0); i++) {
msnprintf(optr, left, "%02x", ptr[i]);
width += 2;
optr += 2;
return CURL_SOCKET_BAD;
}
if(!config.port)
- s4port = (unsigned short)((buffer[SOCKS4_DSTPORT]<<8) |
+ s4port = (unsigned short)((buffer[SOCKS4_DSTPORT] << 8) |
(buffer[SOCKS4_DSTPORT + 1]));
else
s4port = config.port;
if(!config.port) {
unsigned char *portp = &buffer[SOCKS5_DSTADDR + len];
- s5port = (unsigned short)((portp[0]<<8) | (portp[1]));
+ s5port = (unsigned short)((portp[0] << 8) | (portp[1]));
}
else
s5port = config.port;
bool unlink_socket = false;
#endif
- while(argc>arg) {
+ while(argc > arg) {
if(!strcmp("--version", argv[arg])) {
printf("socksd IPv4%s\n",
#ifdef USE_IPV6
}
else if(!strcmp("--pidfile", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
pidname = argv[arg++];
}
else if(!strcmp("--portfile", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
portname = argv[arg++];
}
else if(!strcmp("--config", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
configfile = argv[arg++];
}
else if(!strcmp("--backend", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
backendaddr = argv[arg++];
}
else if(!strcmp("--backendport", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
backendport = (unsigned short)atoi(argv[arg++]);
}
else if(!strcmp("--logfile", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
serverlogfile = argv[arg++];
}
else if(!strcmp("--reqfile", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
reqlogfile = argv[arg++];
}
else if(!strcmp("--ipv6", argv[arg])) {
}
else if(!strcmp("--unix-socket", argv[arg])) {
arg++;
- if(argc>arg) {
+ if(argc > arg) {
#ifdef USE_UNIX_SOCKETS
struct sockaddr_un sau;
unix_socket = argv[arg];
}
else if(!strcmp("--port", argv[arg])) {
arg++;
- if(argc>arg) {
+ if(argc > arg) {
char *endptr;
unsigned long ulnum = strtoul(argv[arg], &endptr, 10);
port = curlx_ultous(ulnum);
req->callcount++;
logmsg("Process %zu bytes request%s", req->offset,
- req->callcount > 1?" [CONTINUED]":"");
+ req->callcount > 1 ? " [CONTINUED]" : "");
/* try to figure out the request characteristics as soon as possible, but
only once! */
char dumpfile[256];
msnprintf(dumpfile, sizeof(dumpfile), "%s/%s",
- logdir, is_proxy?REQUEST_PROXY_DUMP:REQUEST_DUMP);
+ logdir, is_proxy ? REQUEST_PROXY_DUMP : REQUEST_DUMP);
if(!reqbuf)
return;
char responsedump[256];
msnprintf(responsedump, sizeof(responsedump), "%s/%s",
- logdir, is_proxy?RESPONSE_PROXY_DUMP:RESPONSE_DUMP);
+ logdir, is_proxy ? RESPONSE_PROXY_DUMP:RESPONSE_DUMP);
switch(req->rcmd) {
default:
/* select the <data> tag for "normal" requests and the <connect> one
for CONNECT requests (within the <reply> section) */
- const char *section = req->connect_request?"connect":"data";
+ const char *section = req->connect_request ? "connect" : "data";
if(req->partno)
msnprintf(partbuf, sizeof(partbuf), "%s%ld", section, req->partno);
/* a default CONNECT port is basically pointless but still ... */
size_t socket_idx;
- while(argc>arg) {
+ while(argc > arg) {
if(!strcmp("--version", argv[arg])) {
puts("sws IPv4"
#ifdef USE_IPV6
}
else if(!strcmp("--pidfile", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
pidname = argv[arg++];
}
else if(!strcmp("--portfile", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
portname = argv[arg++];
}
else if(!strcmp("--logfile", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
serverlogfile = argv[arg++];
}
else if(!strcmp("--logdir", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
logdir = argv[arg++];
}
else if(!strcmp("--cmdfile", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
cmdfile = argv[arg++];
}
else if(!strcmp("--gopher", argv[arg])) {
}
else if(!strcmp("--unix-socket", argv[arg])) {
arg++;
- if(argc>arg) {
+ if(argc > arg) {
#ifdef USE_UNIX_SOCKETS
unix_socket = argv[arg];
if(strlen(unix_socket) >= sizeof(me.sau.sun_path)) {
}
else if(!strcmp("--port", argv[arg])) {
arg++;
- if(argc>arg) {
+ if(argc > arg) {
char *endptr;
unsigned long ulnum = strtoul(argv[arg], &endptr, 10);
if((endptr != argv[arg] + strlen(argv[arg])) ||
}
else if(!strcmp("--srcdir", argv[arg])) {
arg++;
- if(argc>arg) {
+ if(argc > arg) {
path = argv[arg];
arg++;
}
}
else if(!strcmp("--keepalive", argv[arg])) {
arg++;
- if(argc>arg) {
+ if(argc > arg) {
char *endptr;
unsigned long ulnum = strtoul(argv[arg], &endptr, 10);
if((endptr != argv[arg] + strlen(argv[arg])) ||
what the client asks for, but also use this as a hint that we run as
a proxy and do a few different internal choices */
arg++;
- if(argc>arg) {
+ if(argc > arg) {
connecthost = argv[arg];
arg++;
is_proxy = TRUE;
char *part;
size_t partlen;
- if(argc< 3) {
+ if(argc < 3) {
printf("./testpart main sub\n");
}
else {
memset(&test, 0, sizeof(test));
- while(argc>arg) {
+ while(argc > arg) {
if(!strcmp("--version", argv[arg])) {
printf("tftpd IPv4%s\n",
#ifdef USE_IPV6
}
else if(!strcmp("--pidfile", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
pidname = argv[arg++];
}
else if(!strcmp("--portfile", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
portname = argv[arg++];
}
else if(!strcmp("--logfile", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
serverlogfile = argv[arg++];
}
else if(!strcmp("--logdir", argv[arg])) {
arg++;
- if(argc>arg)
+ if(argc > arg)
logdir = argv[arg++];
}
else if(!strcmp("--ipv4", argv[arg])) {
}
else if(!strcmp("--port", argv[arg])) {
arg++;
- if(argc>arg) {
+ if(argc > arg) {
char *endptr;
unsigned long ulnum = strtoul(argv[arg], &endptr, 10);
port = curlx_ultous(ulnum);
}
else if(!strcmp("--srcdir", argv[arg])) {
arg++;
- if(argc>arg) {
+ if(argc > arg) {
path = argv[arg];
arg++;
}
logmsg("ctrl_event_handler: %lu", dwCtrlType);
switch(dwCtrlType) {
#ifdef SIGINT
- case CTRL_C_EVENT: signum = SIGINT; break;
+ case CTRL_C_EVENT:
+ signum = SIGINT;
+ break;
#endif
#ifdef SIGTERM
- case CTRL_CLOSE_EVENT: signum = SIGTERM; break;
+ case CTRL_CLOSE_EVENT:
+ signum = SIGTERM;
+ break;
#endif
#ifdef SIGBREAK
- case CTRL_BREAK_EVENT: signum = SIGBREAK; break;
+ case CTRL_BREAK_EVENT:
+ signum = SIGBREAK;
+ break;
#endif
- default: return FALSE;
+ default:
+ return FALSE;
}
if(signum) {
logmsg("ctrl_event_handler: %lu -> %d", dwCtrlType, signum);
if(hwnd == hidden_main_window) {
switch(uMsg) {
#ifdef SIGTERM
- case WM_CLOSE: signum = SIGTERM; break;
+ case WM_CLOSE:
+ signum = SIGTERM;
+ break;
#endif
- case WM_DESTROY: PostQuitMessage(0); break;
+ case WM_DESTROY:
+ PostQuitMessage(0);
+ break;
}
if(signum) {
logmsg("main_window_proc: %d -> %d", uMsg, signum);
sa.sa_handler = handler;
sigemptyset(&sa.sa_mask);
sigaddset(&sa.sa_mask, signum);
- sa.sa_flags = restartable? SA_RESTART: 0;
+ sa.sa_flags = restartable ? SA_RESTART : 0;
if(sigaction(signum, &sa, &oldsa))
return SIG_ERR;
return;
splayprint(t->larger, d + 1, output);
- for(i = 0; i<d; i++)
+ for(i = 0; i < d; i++)
if(output)
printf(" ");
bool same = (time_sec == expected_seconds);
fprintf(stderr, "is %d us same as %d seconds? %s\n",
(int)time_usec, expected_seconds,
- same?"Yes":"No");
+ same ? "Yes" : "No");
return same;
}
Curl_expire(data, ctx->fail_delay_ms, EXPIRE_RUN_NOW);
out:
- *pcf = (!result)? cf : NULL;
+ *pcf = (!result) ? cf : NULL;
if(result) {
free(cf);
free(ctx);
if(tr->cf6.creations && tr->cf4.creations && tc->pref_family) {
/* did ipv4 and ipv6 both, expect the preferred family to start right arway
* with the other being delayed by the happy_eyeball_timeout */
- struct ai_family_stats *stats1 = !strcmp(tc->pref_family, "v6")?
+ struct ai_family_stats *stats1 = !strcmp(tc->pref_family, "v6") ?
&tr->cf6 : &tr->cf4;
- struct ai_family_stats *stats2 = !strcmp(tc->pref_family, "v6")?
+ struct ai_family_stats *stats2 = !strcmp(tc->pref_family, "v6") ?
&tr->cf4 : &tr->cf6;
if(stats1->first_created > 100) {
struct buf_chunk *chunk;
if(!q->tail) {
- return q->head? "tail is NULL, but head is not" : NULL;
+ return q->head ? "tail is NULL, but head is not" : NULL;
}
chunk = q->head;
projects / thirdparty / curl.git / commitdiff
