{
FILE *fp = (FILE *) userp;
- if(-1 == fseek(fp, (long) offset, origin))
+ if(fseek(fp, (long) offset, origin) == -1)
/* could not seek */
return CURL_SEEKFUNC_CANTSEEK;
ip->maskbits = 128;
#endif
- if(1 != inet_pton(ip->family, ip->str, &ip->netaddr)) {
+ if(inet_pton(ip->family, ip->str, &ip->netaddr) != 1) {
free(ip->str);
free(ip);
return NULL;
NULL, /* default attributes please */
pull_one_url,
(void *)urls[i]);
- if(0 != error)
+ if(error)
fprintf(stderr, "Couldn't run thread number %d, errno %d\n", i, error);
else
fprintf(stderr, "Thread %d, gets %s\n", i, urls[i]);
CURLcode result = CURLE_GOT_NOTHING;
curl_off_t remoteFileSizeByte = sftpGetRemoteFileSize(remotepath);
- if(-1 == remoteFileSizeByte) {
+ if(remoteFileSizeByte == -1) {
printf("Error reading the remote file size: unable to resume upload\n");
return -1;
}
NULL, /* default attributes please */
pull_one_url,
NULL);
- if(0 != error)
+ if(error)
fprintf(stderr, "Couldn't run thread number %d, errno %d\n", i, error);
else
fprintf(stderr, "Thread %d, gets %s\n", i, urls[i]);
NULL, /* default attributes please */
pull_one_url,
(void *)urls[i]);
- if(0 != error)
+ if(error)
fprintf(stderr, "Couldn't run thread number %d, errno %d\n", i, error);
else
fprintf(stderr, "Thread %d, gets %s\n", i, urls[i]);
```c
data->set.http_disable_hostname_check_before_authentication =
- (0 != va_arg(param, long)) ? TRUE : FALSE;
+ va_arg(param, long) ? TRUE : FALSE;
```
Function invoke with an open parenthesis:
#ifdef USE_IPV6
else {
char ipv6_unused[16];
- if(1 == curlx_inet_pton(AF_INET6, as->dst.host, ipv6_unused)) {
+ if(curlx_inet_pton(AF_INET6, as->dst.host, ipv6_unused) == 1) {
dst6_pre = "[";
dst6_post = "]";
}
- if(1 == curlx_inet_pton(AF_INET6, as->src.host, ipv6_unused)) {
+ if(curlx_inet_pton(AF_INET6, as->src.host, ipv6_unused) == 1) {
src6_pre = "[";
src6_post = "]";
}
#endif
- if(0 != getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void *)&err, &errSize))
+ if(getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void *)&err, &errSize))
err = SOCKERRNO;
#ifdef UNDER_CE
/* Old Windows CE versions do not support SO_ERROR */
err = 0;
}
#endif
- if((0 == err) || (SOCKEISCONN == err))
+ if((err == 0) || (SOCKEISCONN == err))
/* we are connected, awesome! */
rc = TRUE;
else
return CURLE_OK;
}
- if(0 == getsockname(ctx->sock, (struct sockaddr *) &add, &size)) {
+ if(!getsockname(ctx->sock, (struct sockaddr *) &add, &size)) {
size = sizeof(add);
#ifdef HAVE_ACCEPT4
s_accepted = accept4(ctx->sock, (struct sockaddr *) &add, &size,
struct connectdata *conn = Curl_node_elem(curr);
curr = Curl_node_next(curr);
- if(1 == func(data, conn, param)) {
+ if(func(data, conn, param) == 1) {
return TRUE;
}
}
/* cookie_path must not have last '/' separator. ex: /sample */
cookie_path_len = strlen(cookie_path);
- if(1 == cookie_path_len) {
+ if(cookie_path_len == 1) {
/* cookie_path must be '/' */
return TRUE;
}
/* #-fragments are already cut off! */
- if(0 == strlen(uri_path) || uri_path[0] != '/')
+ if(strlen(uri_path) == 0 || uri_path[0] != '/')
uri_path = "/";
/*
break;
}
}
- if(6 == fields) {
+ if(fields == 6) {
/* we got a cookie with blank contents, fix it */
co->value = strdup("");
if(!co->value)
fields++;
}
- if(7 != fields)
+ if(fields != 7)
/* we did not find the sufficient number of fields */
return CERR_FIELDS;
#else
int res = getaddrinfo(hostname, service, hints, result);
#endif
- if(0 == res)
+ if(res == 0)
/* success */
curl_dbg_log("ADDR %s:%d getaddrinfo() = %p\n",
source, line, (void *)*result);
unsigned int bits)
{
bits %= 64;
- if(0 == bits)
+ if(bits == 0)
return value;
/* Defined in a form which modern compiler could optimize. */
return (value >> bits) | (value << (64 - bits));
DEBUGASSERT((data != NULL) || (length == 0));
- if(0 == length)
+ if(length == 0)
return CURLE_OK; /* Shortcut, do nothing */
/* Note: (count & (CURL_SHA512_256_BLOCK_SIZE-1))
ctx->count_bits_hi += ctx->count >> 61;
ctx->count &= CURL_UINT64_C(0x1FFFFFFFFFFFFFFF);
- if(0 != bytes_have) {
+ if(bytes_have) {
unsigned int bytes_left = CURL_SHA512_256_BLOCK_SIZE - bytes_have;
if(length >= bytes_left) {
/* Combine new data with data in the buffer and process the full
length -= CURL_SHA512_256_BLOCK_SIZE;
}
- if(0 != length) {
+ if(length) {
/* Copy incomplete block of new data (if any)
to the buffer. */
memcpy(((unsigned char *) ctx_buf) + bytes_have, data, length);
(HAVE_BUILTIN_AVAILABLE == 1)
have_clock_gettime &&
#endif
- (0 == clock_gettime(CLOCK_MONOTONIC_RAW, &tsnow))) {
+ (clock_gettime(CLOCK_MONOTONIC_RAW, &tsnow) == 0)) {
cnow.tv_sec = tsnow.tv_sec;
cnow.tv_usec = (int)(tsnow.tv_nsec / 1000);
}
(HAVE_BUILTIN_AVAILABLE == 1)
have_clock_gettime &&
#endif
- (0 == clock_gettime(CLOCK_MONOTONIC, &tsnow))) {
+ (clock_gettime(CLOCK_MONOTONIC, &tsnow) == 0)) {
cnow.tv_sec = tsnow.tv_sec;
cnow.tv_usec = (int)(tsnow.tv_nsec / 1000);
}
struct curltime cnow;
uint64_t usecs;
- if(0 == timebase.denom)
+ if(timebase.denom == 0)
(void)mach_timebase_info(&timebase);
usecs = mach_absolute_time();
return CURLE_WRITE_ERROR;
}
- if(-1 != data->state.infilesize)
+ if(data->state.infilesize != -1)
/* known size of data to "upload" */
Curl_pgrsSetUploadSize(data, data->state.infilesize);
fd = file->fd;
/* VMS: This only works reliable for STREAMLF files */
- if(-1 != fstat(fd, &statbuf)) {
+ if(fstat(fd, &statbuf) != -1) {
if(!S_ISDIR(statbuf.st_mode))
expected_size = statbuf.st_size;
/* and store the modification time */
if(ftpcode)
*ftpcode = code;
- if(421 == code) {
+ if(code == 421) {
/* 421 means "Service not available, closing control connection." and FTP
* servers use it to signal that idle session timeout has been exceeded.
* If we ignored the response, it could end up hanging in some cases.
if(instate == FTP_SIZE) {
#ifdef CURL_FTP_HTTPSTYLE_HEAD
- if(-1 != filesize) {
+ if(filesize != -1) {
char clbuf[128];
int clbuflen = msnprintf(clbuf, sizeof(clbuf),
"Content-Length: %" FMT_OFF_T "\r\n", filesize);
}
}
else {
- if((-1 != data->req.size) &&
+ if((data->req.size != -1) &&
(data->req.size != data->req.bytecount) &&
(data->req.maxdownload != data->req.bytecount)) {
failf(data, "Received only partial file: %" FMT_OFF_T " bytes",
* The AI_NUMERICHOST must not be set to get synthesized IPv6 address from
* an IPv4 address on iOS and macOS.
*/
- if((1 == curlx_inet_pton(AF_INET, hostname, addrbuf)) ||
- (1 == curlx_inet_pton(AF_INET6, hostname, addrbuf))) {
+ if((curlx_inet_pton(AF_INET, hostname, addrbuf) == 1) ||
+ (curlx_inet_pton(AF_INET6, hostname, addrbuf) == 1)) {
/* the given address is numerical only, prevent a reverse lookup */
hints.ai_flags = AI_NUMERICHOST;
}
like to call http2_handle_stream_close to properly close a
stream. In order to do this, we keep reading until we
close the stream. */
- if((0 == k->maxdownload) && (k->httpversion_sent < 20))
+ if((k->maxdownload == 0) && (k->httpversion_sent < 20))
k->download_done = TRUE;
/* final response without error, prepare to receive the body */
}
else {
const char *p;
- if(0 == ch->hexindex) {
+ if(ch->hexindex == 0) {
/* This is illegal data, we received junk where we expected
a hexadecimal digit. */
failf(data, "chunk hex-length char not a hex digit: 0x%x", *buf);
/* waiting for the LF after a chunk size */
if(*buf == 0x0a) {
/* we are now expecting data to come, unless size was zero! */
- if(0 == ch->datasize) {
+ if(ch->datasize == 0) {
ch->state = CHUNK_TRAILER; /* now check for trailers */
}
else {
FMT_OFF_T " bytes in chunk remain",
piece, ch->datasize);
- if(0 == ch->datasize)
+ if(ch->datasize == 0)
/* end of data this round, we now expect a trailing CRLF */
ch->state = CHUNK_POSTLF;
break;
{
int res = (socketpair)(domain, type, protocol, socket_vector);
- if(source && (0 == res))
+ if(source && (res == 0))
curl_dbg_log("FD %s:%d socketpair() = "
"%" FMT_SOCKET_T " %" FMT_SOCKET_T "\n",
source, line, socket_vector[0], socket_vector[1]);
/* strange input */
return FALSE;
- if(1 != curlx_inet_pton(AF_INET, ipv4, &address))
+ if(curlx_inet_pton(AF_INET, ipv4, &address) != 1)
return FALSE;
- if(1 != curlx_inet_pton(AF_INET, network, &check))
+ if(curlx_inet_pton(AF_INET, network, &check) != 1)
return FALSE;
if(bits && (bits != 32)) {
rest = bits & 0x07;
if((bytes > 16) || ((bytes == 16) && rest))
return FALSE;
- if(1 != curlx_inet_pton(AF_INET6, ipv6, address))
+ if(curlx_inet_pton(AF_INET6, ipv6, address) != 1)
return FALSE;
- if(1 != curlx_inet_pton(AF_INET6, network, check))
+ if(curlx_inet_pton(AF_INET6, network, check) != 1)
return FALSE;
if(bytes && memcmp(address, check, bytes))
return FALSE;
else {
unsigned int address;
namelen = strlen(name);
- if(1 == curlx_inet_pton(AF_INET, name, &address))
+ if(curlx_inet_pton(AF_INET, name, &address) == 1)
type = TYPE_IPV4;
else {
/* ignore trailing dots in the hostname */
/* Figure out the exact time for the time span */
span_ms = curlx_timediff(now, p->speeder_time[checkindex]);
- if(0 == span_ms)
+ if(span_ms == 0)
span_ms = 1; /* at least one millisecond MUST have passed */
/* Calculate the average speed the last 'span_ms' milliseconds */
* This gives deterministic BODY writes on varying buffer receive
* lengths. */
nwrite = nbytes;
- if(-1 != data->req.maxdownload) {
+ if(data->req.maxdownload != -1) {
size_t wmax = get_max_body_write_len(data, data->req.maxdownload);
if(nwrite > wmax) {
excess_len = nbytes - wmax;
int err = fseek(data->state.in, 0, SEEK_SET);
CURL_TRC_READ(data, "cr_in, rewind via fseek -> %d(%d)",
(int)err, (int)errno);
- if(-1 != err)
+ if(err != -1)
/* successful rewind */
return CURLE_OK;
}
static CURLcode setopt_long(struct Curl_easy *data, CURLoption option,
long arg)
{
- bool enabled = (0 != arg);
+ bool enabled = !!arg;
unsigned long uarg = (unsigned long)arg;
switch(option) {
case CURLOPT_DNS_CACHE_TIMEOUT:
#ifdef USE_IPV6
if(conn->bits.ipv6_ip) {
char ip6[16];
- if(1 != curlx_inet_pton(AF_INET6, sx->hostname, ip6))
+ if(curlx_inet_pton(AF_INET6, sx->hostname, ip6) != 1)
return CURLPX_BAD_ADDRESS_TYPE;
socksreq[len++] = 4;
memcpy(&socksreq[len], ip6, sizeof(ip6));
}
else
#endif
- if(1 == curlx_inet_pton(AF_INET, sx->hostname, ip4)) {
+ if(curlx_inet_pton(AF_INET, sx->hostname, ip4) == 1) {
socksreq[len++] = 1;
memcpy(&socksreq[len], ip4, sizeof(ip4));
len += sizeof(ip4);
code = Curl_conn_cf_send(cf->next, data, (char *)socksreq, 4,
FALSE, &nwritten);
- if(code || (4 != nwritten)) {
+ if(code || (nwritten != 4)) {
failf(data, "Failed to send GSS-API authentication request.");
gss_release_name(&gss_status, &server);
gss_release_buffer(&gss_status, &gss_recv_token);
code = Curl_conn_cf_send(cf->next, data, (char *)socksreq, 4, FALSE,
&nwritten);
- if(code || (4 != nwritten)) {
+ if(code || (nwritten != 4)) {
failf(data, "Failed to send GSS-API encryption request.");
gss_release_buffer(&gss_status, &gss_w_token);
Curl_gss_delete_sec_context(&gss_status, &gss_context, NULL);
memcpy(socksreq, &gss_enc, 1);
code = Curl_conn_cf_send(cf->next, data, (char *)socksreq, 1, FALSE,
&nwritten);
- if(code || (1 != nwritten)) {
+ if(code || (nwritten != 1)) {
failf(data, "Failed to send GSS-API encryption type.");
Curl_gss_delete_sec_context(&gss_status, &gss_context, NULL);
return CURLE_COULDNT_CONNECT;
code = Curl_conn_cf_send(cf->next, data, (char *)socksreq, 4, FALSE,
&written);
- if(code || (4 != written)) {
+ if(code || (written != 4)) {
failf(data, "Failed to send SSPI authentication request.");
free(service_name);
if(sspi_send_token.pvBuffer)
code = Curl_conn_cf_send(cf->next, data, (char *)socksreq, 4, FALSE,
&written);
- if(code || (4 != written)) {
+ if(code || (written != 4)) {
failf(data, "Failed to send SSPI encryption request.");
if(sspi_send_token.pvBuffer)
Curl_pSecFn->FreeContextBuffer(sspi_send_token.pvBuffer);
memcpy(socksreq, &gss_enc, 1);
code = Curl_conn_cf_send(cf->next, data, (char *)socksreq, 1, FALSE,
&written);
- if(code || (1 != written)) {
+ if(code || (written != 1)) {
failf(data, "Failed to send SSPI encryption type.");
Curl_pSecFn->DeleteSecurityContext(&sspi_context);
return CURLE_COULDNT_CONNECT;
first++;
second++;
}
- if(0 == max)
+ if(max == 0)
return 1; /* they are equal this far */
return Curl_raw_toupper(*first) == Curl_raw_toupper(*second);
* storage is supplied via 'strerrbuf' and 'buflen' to hold the generated
* message string, or EINVAL if 'errnum' is not a valid error number.
*/
- if(0 != strerror_r(err, buf, buflen)) {
+ if(strerror_r(err, buf, buflen)) {
if('\0' == buf[0])
curl_msnprintf(buf, buflen, "Unknown error %d", err);
}
}
/* If there is nothing more to send/recv, the request is done */
- if(0 == (k->keepon&(KEEP_RECVBITS|KEEP_SENDBITS)))
+ if((k->keepon & (KEEP_RECVBITS|KEEP_SENDBITS)) == 0)
data->req.done = TRUE;
out:
{
char dest[16]; /* fits a binary IPv6 address */
hostname[hlen] = 0; /* end the address there */
- if(1 != curlx_inet_pton(AF_INET6, hostname, dest))
+ if(curlx_inet_pton(AF_INET6, hostname, dest) != 1)
return CURLUE_BAD_IPV6;
if(curlx_inet_ntop(AF_INET6, dest, hostname, hlen)) {
hlen = strlen(hostname); /* might be shorter now */
DEBUGASSERT(ctx && ctx->backend);
backend = (struct gtls_ssl_backend_data *)ctx->backend;
if(backend->gtls.session &&
- 0 != gnutls_record_check_pending(backend->gtls.session))
+ gnutls_record_check_pending(backend->gtls.session) != 0)
return TRUE;
return FALSE;
}
static int passwd_callback(char *buf, int num, int encrypting,
void *password)
{
- DEBUGASSERT(0 == encrypting);
+ DEBUGASSERT(encrypting == 0);
if(!encrypting && num >= 0 && password) {
int klen = curlx_uztosi(strlen((char *)password));
*/
static bool rand_enough(void)
{
- return 0 != RAND_status();
+ return RAND_status() != 0;
}
static CURLcode ossl_seed(struct Curl_easy *data)
/* 1 is fine
0 is "not successful but was shut down controlled"
<0 is "handshake was not successful, because a fatal error occurred" */
- if(1 != err) {
+ if(err != 1) {
int detail = SSL_get_error(octx->ssl, err);
CURL_TRC_CF(data, cf, "SSL_connect() -> err=%d, detail=%d", err, detail);
{
const char *startCur = ciphers;
int algCount = 0;
- while(startCur && (0 != *startCur) && (algCount < NUM_CIPHERS)) {
+ while(startCur && *startCur && (algCount < NUM_CIPHERS)) {
curl_off_t alg;
if(curlx_str_number(&startCur, &alg, INT_MAX) || !alg)
alg = get_alg_id_by_name(startCur);
result = CURLE_SEND_ERROR;
break;
}
- else if(0 == what) {
+ else if(what == 0) {
failf(data, "schannel: timed out sending data "
"(bytes sent: %zu)", *pnwritten);
result = CURLE_OPERATION_TIMEDOUT;
pem_count = begin_pos - pem;
/* Invalid if not at beginning AND not directly following \n */
- if(0 != pem_count && '\n' != pem[pem_count - 1])
+ if(pem_count && '\n' != pem[pem_count - 1])
return CURLE_BAD_CONTENT_ENCODING;
/* 26 is length of "-----BEGIN PUBLIC KEY-----" */
result = CURLE_RECV_ERROR;
goto out;
}
- else if(0 == what) {
+ else if(what == 0) {
/* timeout */
failf(data, "SSL shutdown timeout");
result = CURLE_OPERATION_TIMEDOUT;
}
}
#ifdef USE_ECH_WOLFSSL
- else if(-1 == detail) {
+ else if(detail == -1) {
/* try access a retry_config ECHConfigList for tracing */
byte echConfigs[1000];
word32 echConfigsLen = 1000;
/* Create directory. Ignore access denied error to allow traversal. */
/* !checksrc! disable ERRNOVAR 1 */
- if(!skip && (-1 == mkdir(curlx_dyn_ptr(&dirbuf), (mode_t)0000750)) &&
+ if(!skip && (mkdir(curlx_dyn_ptr(&dirbuf), (mode_t)0000750) == -1) &&
(errno != EACCES) && (errno != EEXIST)) {
show_dir_errno(global, curlx_dyn_ptr(&dirbuf));
result = CURLE_WRITE_ERROR;
}
#else
struct_stat statbuf;
- if(-1 != stat(filename, &statbuf)) {
+ if(stat(filename, &statbuf) != -1) {
*stamp = (curl_off_t)statbuf.st_mtime;
rc = 0;
}
break;
}
config->condtime = (curl_off_t)curl_getdate(nextarg, NULL);
- if(-1 == config->condtime) {
+ if(config->condtime == -1) {
curl_off_t value;
/* now let's see if it is a filename to get the time from instead! */
int rc = getfiletime(nextarg, config->global, &value);
ssize_t nread;
bool disabled;
int fd = open("/dev/tty", O_RDONLY);
- if(-1 == fd)
+ if(fd == -1)
fd = STDIN_FILENO; /* use stdin if the tty could not be used */
disabled = ttyecho(FALSE, fd); /* disable terminal echo */
while(!ISBLANK(ptr[cut]) && cut) {
cut--;
}
- if(0 == cut)
+ if(cut == 0)
/* not a single cutting position was found, just cut it at the
max text width then! */
cut = width-1;
of the file as it is now and open it for append instead */
struct_stat fileinfo;
/* VMS -- Danger, the filesize is only valid for stream files */
- if(0 == stat(per->outfile, &fileinfo))
+ if(stat(per->outfile, &fileinfo) == 0)
/* set offset to current file size: */
config->resume_from = fileinfo.st_size;
else
memset(value, 0, sizeof(value)); /* Avoid valgrind false positive. */
memcpy(buf, p, n);
buf[n] = 0;
- if(2 == sscanf(buf, "%79[^=]=%79[^,]", part, value)) {
+ if(sscanf(buf, "%79[^=]=%79[^,]", part, value) == 2) {
CURLUPart what = part2id(part);
#if 0
/* for debugging this */
curl_mfprintf(stderr, "unexpected return code line %u\n", __LINE__);
rc = curl_url_get(u, clear_url_list[i].part, &p, 0);
- if(rc != clear_url_list[i].ucode || (clear_url_list[i].out &&
- 0 != strcmp(p, clear_url_list[i].out))) {
+ if(rc != clear_url_list[i].ucode ||
+ (clear_url_list[i].out && strcmp(p, clear_url_list[i].out) != 0)) {
curl_mfprintf(stderr, "unexpected return code line %u\n", __LINE__);
error++;
}
flag = 1;
- if(0 != setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
- (void *)&flag, sizeof(flag))) {
+ if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
+ (void *)&flag, sizeof(flag))) {
error = SOCKERRNO;
logmsg("setsockopt(SO_REUSEADDR) failed with error (%d) %s",
error, sstrerror(error));
while(fgets(buffer, sizeof(buffer), fp)) {
char key[32];
char value[32];
- if(2 == sscanf(buffer, "%31s %31s", key, value)) {
+ if(sscanf(buffer, "%31s %31s", key, value) == 2) {
if(!strcmp(key, "version")) {
m_config.version = byteval(value);
logmsg("version [%d] set", m_config.version);
logmsg("instructed to stream");
req->rcmd = RCMD_STREAM;
}
- else if(1 == sscanf(ptr, "pipe: %d", &num)) {
+ else if(sscanf(ptr, "pipe: %d", &num) == 1) {
logmsg("instructed to allow a pipe size of %d", num);
if(num < 0)
logmsg("negative pipe size ignored");
req->pipe = num-1; /* decrease by one since we don't count the
first request in this number */
}
- else if(1 == sscanf(ptr, "skip: %d", &num)) {
+ else if(sscanf(ptr, "skip: %d", &num) == 1) {
logmsg("instructed to skip this number of bytes %d", num);
req->skip = num;
}
else {
FILE *stream = test2fopen(req->testno, logdir);
char partbuf[80]="data";
- if(0 != req->partno)
+ if(req->partno)
snprintf(partbuf, sizeof(partbuf), "data%ld", req->partno);
if(!stream) {
error = errno;
int num;
ptr = cmd;
do {
- if(2 == sscanf(ptr, "%31s %d", command, &num)) {
+ if(sscanf(ptr, "%31s %d", command, &num) == 2) {
if(!strcmp("wait", command)) {
logmsg("Told to sleep for %d seconds", num);
quarters = num * 4;
}
flag = 1;
- if(0 != setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
- (void *)&flag, sizeof(flag))) {
+ if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
+ (void *)&flag, sizeof(flag))) {
error = SOCKERRNO;
logmsg("setsockopt(SO_REUSEADDR) failed with error (%d) %s",
error, sstrerror(error));
while(fgets(buffer, sizeof(buffer), fp)) {
char key[32];
char value[260];
- if(2 == sscanf(buffer, "%31s %259s", key, value)) {
+ if(sscanf(buffer, "%31s %259s", key, value) == 2) {
if(!strcmp(key, "version")) {
s_config.version = byteval(value);
logmsg("version [%d] set", s_config.version);
int testnum = DOCNUMBER_NOTHING;
char buf[256];
while(fgets(buf, sizeof(buf), f)) {
- if(1 == sscanf(buf, "Testnum %d", &testnum)) {
+ if(sscanf(buf, "Testnum %d", &testnum) == 1) {
logmsg("[%s] cmdfile says testnum %d", cmdfile, testnum);
req->testno = testnum;
}
logmsg("swsclose: close this connection after response");
req->close = TRUE;
}
- else if(1 == sscanf(cmd, "skip: %d", &num)) {
+ else if(sscanf(cmd, "skip: %d", &num) == 1) {
logmsg("instructed to skip this number of bytes %d", num);
req->skip = num;
}
logmsg("instructed to reject Expect: 100-continue");
req->noexpect = TRUE;
}
- else if(1 == sscanf(cmd, "delay: %d", &num)) {
+ else if(sscanf(cmd, "delay: %d", &num) == 1) {
logmsg("instructed to delay %d msecs after connect", num);
req->delay = num;
}
- else if(1 == sscanf(cmd, "writedelay: %d", &num)) {
+ else if(sscanf(cmd, "writedelay: %d", &num) == 1) {
logmsg("instructed to delay %d msecs between packets", num);
req->writedelay = num;
}
int num;
ptr = cmd;
do {
- if(2 == sscanf(ptr, "%31s %d", command, &num)) {
+ if(sscanf(ptr, "%31s %d", command, &num) == 2) {
if(!strcmp("wait", command)) {
logmsg("Told to sleep for %d seconds", num);
quarters = num * 4;
if(socket_domain_is_ip()) {
/* Disable the Nagle algorithm */
curl_socklen_t flag = 1;
- if(0 != setsockopt(serverfd, IPPROTO_TCP, TCP_NODELAY,
- (void *)&flag, sizeof(flag)))
+ if(setsockopt(serverfd, IPPROTO_TCP, TCP_NODELAY,
+ (void *)&flag, sizeof(flag)))
logmsg("====> TCP_NODELAY for server connection failed");
}
#endif
/* We want to do the connect() in a non-blocking mode, since
* Windows has an internal retry logic that may lead to long
* timeouts if the peer is not listening. */
- if(0 != curlx_nonblock(serverfd, TRUE)) {
+ if(curlx_nonblock(serverfd, TRUE)) {
error = SOCKERRNO;
logmsg("curlx_nonblock(TRUE) failed with error (%d) %s",
error, sstrerror(error));
goto error;
else if(rc > 0) {
curl_socklen_t errSize = sizeof(error);
- if(0 != getsockopt(serverfd, SOL_SOCKET, SO_ERROR,
- (void *)&error, &errSize))
+ if(getsockopt(serverfd, SOL_SOCKET, SO_ERROR,
+ (void *)&error, &errSize))
error = SOCKERRNO;
- if((0 == error) || (SOCKEISCONN == error))
+ if((error == 0) || (SOCKEISCONN == error))
goto success;
else if((error != SOCKEINPROGRESS) && (error != SOCKEWOULDBLOCK))
goto error;
logmsg("connected fine to %s%s%s:%hu, now tunnel",
op_br, ipaddr, cl_br, port);
- if(0 != curlx_nonblock(serverfd, FALSE)) {
+ if(curlx_nonblock(serverfd, FALSE)) {
error = SOCKERRNO;
logmsg("curlx_nonblock(FALSE) failed with error (%d) %s",
error, sstrerror(error));
if(socket_domain_is_ip()) {
/* Disable the Nagle algorithm */
curl_socklen_t flag = 1;
- if(0 != setsockopt(datafd, IPPROTO_TCP, TCP_NODELAY,
- (void *)&flag, sizeof(flag)))
+ if(setsockopt(datafd, IPPROTO_TCP, TCP_NODELAY,
+ (void *)&flag, sizeof(flag)))
logmsg("====> TCP_NODELAY for client DATA connection failed");
}
#endif
return CURL_SOCKET_BAD;
}
- if(0 != curlx_nonblock(msgsock, TRUE)) {
+ if(curlx_nonblock(msgsock, TRUE)) {
error = SOCKERRNO;
logmsg("curlx_nonblock failed with error (%d) %s",
error, sstrerror(error));
return CURL_SOCKET_BAD;
}
- if(0 != setsockopt(msgsock, SOL_SOCKET, SO_KEEPALIVE,
- (void *)&flag, sizeof(flag))) {
+ if(setsockopt(msgsock, SOL_SOCKET, SO_KEEPALIVE,
+ (void *)&flag, sizeof(flag))) {
error = SOCKERRNO;
logmsg("setsockopt(SO_KEEPALIVE) failed with error (%d) %s",
error, sstrerror(error));
* Disable the Nagle algorithm to make it easier to send out a large
* response in many small segments to torture the clients more.
*/
- if(0 != setsockopt(msgsock, IPPROTO_TCP, TCP_NODELAY,
- (void *)&flag, sizeof(flag)))
+ if(setsockopt(msgsock, IPPROTO_TCP, TCP_NODELAY,
+ (void *)&flag, sizeof(flag)))
logmsg("====> TCP_NODELAY failed");
}
#endif
}
flag = 1;
- if(0 != setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
- (void *)&flag, sizeof(flag))) {
+ if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
+ (void *)&flag, sizeof(flag))) {
error = SOCKERRNO;
logmsg("setsockopt(SO_REUSEADDR) failed with error (%d) %s",
error, sstrerror(error));
goto sws_cleanup;
}
- if(0 != curlx_nonblock(sock, TRUE)) {
+ if(curlx_nonblock(sock, TRUE)) {
error = SOCKERRNO;
logmsg("curlx_nonblock failed with error (%d) %s",
error, sstrerror(error));
}
/* formerly
putc(c, file); */
- if(1 != write(test->ofile, &c, 1))
+ if(write(test->ofile, &c, 1) != 1)
break;
skipit:
prevchar = c;
}
flag = 1;
- if(0 != setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
- (void *)&flag, sizeof(flag))) {
+ if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
+ (void *)&flag, sizeof(flag))) {
error = SOCKERRNO;
logmsg("setsockopt(SO_REUSEADDR) failed with error (%d) %s",
error, sstrerror(error));
cmd = orgcmd;
while(cmd && cmdsize) {
char *check;
- if(1 == sscanf(cmd, "writedelay: %d", &num)) {
+ if(sscanf(cmd, "writedelay: %d", &num) == 1) {
logmsg("instructed to delay %d secs between packets", num);
req->writedelay = num;
}
stream = test2fopen(testno, logdir);
- if(0 != partno)
+ if(partno)
snprintf(partbuf, sizeof(partbuf), "data%ld", partno);
if(!stream) {
projects / thirdparty / curl.git / commitdiff
