9253

pending completion

Build # 9253

Build Type

Pull #3263

travis-ci

Committed by

web-flow

Commit Message

tool_cb_wrt: Silence compiler warning

Commit 5bfaa86ce introduced a new
compiler warning on Windows cross compilation with GCC. See below
for an example of the warning from the autobuild logs (whitespace
edited to fit):

/src/tool_cb_wrt.c:175:9: warning: cast from function call of type
    'intptr_t {aka long long int}' to non-matching type 'void *'
    [-Wbad-function-cast]
(HANDLE) _get_osfhandle(fileno(outs->stream)),
^

Store the return value from _get_osfhandle() in an intermediate
variable and cast the variable in WriteConsoleW() rather than the
function call directly to avoid a compiler warning.

In passing, also add inspection of the MultiByteToWideChar() return
value and return failure in case an error is reported.

Pull Request Pull Request #3263: RFC: silence benign warning with pragma

Run Details

21769 of 29059 relevant lines covered (74.91%)

773756.36 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.16

/lib/base64.c

/***************************************************************************
 *                                  _   _ ____  _
 *  Project                     ___| | | |  _ \| |
 *                             / __| | | | |_) | |
 *                            | (__| |_| |  _ <| |___
 *                             \___|\___/|_| \_\_____|
 *
 * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
 *
 * This software is licensed as described in the file COPYING, which
 * you should have received as part of this distribution. The terms
 * are also available at https://curl.haxx.se/docs/copyright.html.
 *
 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
 * copies of the Software, and permit persons to whom the Software is
 * furnished to do so, under the terms of the COPYING file.
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 * KIND, either express or implied.
 *
 ***************************************************************************/

/* Base64 encoding/decoding */

#include "curl_setup.h"
#include "urldata.h" /* for the Curl_easy definition */
#include "warnless.h"
#include "curl_base64.h"
#include "non-ascii.h"

/* The last 3 #include files should be in this order */
#include "curl_printf.h"
#include "curl_memory.h"
#include "memdebug.h"

/* ---- Base64 Encoding/Decoding Table --- */
static const char base64[]=
  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

/* The Base 64 encoding with an URL and filename safe alphabet, RFC 4648
   section 5 */
static const char base64url[]=
  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";

static size_t decodeQuantum(unsigned char *dest, const char *src)
{
  size_t padding = 0;
  const char *s, *p;
  unsigned long i, x = 0;

  for(i = 0, s = src; i < 4; i++, s++) {
    if(*s == '=') {
      x = (x << 6);
      padding++;
    }
    else {
      unsigned long v = 0;
      p = base64;

      while(*p && (*p != *s)) {
        v++;
        p++;
      }

      if(*p == *s)
        x = (x << 6) + v;
      else
        return 0;
    }
  }

  if(padding < 1)
    dest[2] = curlx_ultouc(x & 0xFFUL);

  x >>= 8;
  if(padding < 2)
    dest[1] = curlx_ultouc(x & 0xFFUL);

  x >>= 8;
  dest[0] = curlx_ultouc(x & 0xFFUL);

  return 3 - padding;
}

/*
 * Curl_base64_decode()
 *
 * Given a base64 NUL-terminated string at src, decode it and return a
 * pointer in *outptr to a newly allocated memory area holding decoded
 * data. Size of decoded data is returned in variable pointed by outlen.
 *
 * Returns CURLE_OK on success, otherwise specific error code. Function
 * output shall not be considered valid unless CURLE_OK is returned.
 *
 * When decoded data length is 0, returns NULL in *outptr.
 *
 * @unittest: 1302
 */
CURLcode Curl_base64_decode(const char *src,
                            unsigned char **outptr, size_t *outlen)
{
  size_t srclen = 0;
  size_t length = 0;
  size_t padding = 0;
  size_t i;
  size_t numQuantums;
  size_t rawlen = 0;
  unsigned char *pos;
  unsigned char *newstr;

  *outptr = NULL;
  *outlen = 0;
  srclen = strlen(src);

  /* Check the length of the input string is valid */
  if(!srclen || srclen % 4)
    return CURLE_BAD_CONTENT_ENCODING;

  /* Find the position of any = padding characters */
  while((src[length] != '=') && src[length])
    length++;

  /* A maximum of two = padding characters is allowed */
  if(src[length] == '=') {
    padding++;
    if(src[length + 1] == '=')
      padding++;
  }

  /* Check the = padding characters weren't part way through the input */
  if(length + padding != srclen)
    return CURLE_BAD_CONTENT_ENCODING;

  /* Calculate the number of quantums */
  numQuantums = srclen / 4;

  /* Calculate the size of the decoded string */
  rawlen = (numQuantums * 3) - padding;

  /* Allocate our buffer including room for a zero terminator */
  newstr = malloc(rawlen + 1);
  if(!newstr)
    return CURLE_OUT_OF_MEMORY;

  pos = newstr;

  /* Decode the quantums */
  for(i = 0; i < numQuantums; i++) {
    size_t result = decodeQuantum(pos, src);
    if(!result) {
      free(newstr);

      return CURLE_BAD_CONTENT_ENCODING;
    }

    pos += result;
    src += 4;
  }

  /* Zero terminate */
  *pos = '\0';

  /* Return the decoded data */
  *outptr = newstr;
  *outlen = rawlen;

  return CURLE_OK;
}

static CURLcode base64_encode(const char *table64,
                              struct Curl_easy *data,
                              const char *inputbuff, size_t insize,
                              char **outptr, size_t *outlen)
{
  CURLcode result;
  unsigned char ibuf[3];
  unsigned char obuf[4];
  int i;
  int inputparts;
  char *output;
  char *base64data;
  char *convbuf = NULL;

  const char *indata = inputbuff;

  *outptr = NULL;
  *outlen = 0;

  if(!insize)
    insize = strlen(indata);

#if SIZEOF_SIZE_T == 4
  if(insize > UINT_MAX/4)
    return CURLE_OUT_OF_MEMORY;
#endif

  base64data = output = malloc(insize * 4 / 3 + 4);
  if(!output)
    return CURLE_OUT_OF_MEMORY;

  /*
   * The base64 data needs to be created using the network encoding
   * not the host encoding.  And we can't change the actual input
   * so we copy it to a buffer, translate it, and use that instead.
   */
  result = Curl_convert_clone(data, indata, insize, &convbuf);
  if(result) {
    free(output);
    return result;
  }

  if(convbuf)
    indata = (char *)convbuf;

  while(insize > 0) {
    for(i = inputparts = 0; i < 3; i++) {
      if(insize > 0) {
        inputparts++;
        ibuf[i] = (unsigned char) *indata;
        indata++;
        insize--;
      }
      else
        ibuf[i] = 0;
    }

    obuf[0] = (unsigned char)  ((ibuf[0] & 0xFC) >> 2);
    obuf[1] = (unsigned char) (((ibuf[0] & 0x03) << 4) | \
                               ((ibuf[1] & 0xF0) >> 4));
    obuf[2] = (unsigned char) (((ibuf[1] & 0x0F) << 2) | \
                               ((ibuf[2] & 0xC0) >> 6));
    obuf[3] = (unsigned char)   (ibuf[2] & 0x3F);

    switch(inputparts) {
    case 1: /* only one byte read */
      snprintf(output, 5, "%c%c==",
               table64[obuf[0]],
               table64[obuf[1]]);
      break;

    case 2: /* two bytes read */
      snprintf(output, 5, "%c%c%c=",
               table64[obuf[0]],
               table64[obuf[1]],
               table64[obuf[2]]);
      break;

    default:
      snprintf(output, 5, "%c%c%c%c",
               table64[obuf[0]],
               table64[obuf[1]],
               table64[obuf[2]],
               table64[obuf[3]]);
      break;
    }
    output += 4;
  }

  /* Zero terminate */
  *output = '\0';

  /* Return the pointer to the new data (allocated memory) */
  *outptr = base64data;

  free(convbuf);

  /* Return the length of the new data */
  *outlen = strlen(base64data);

  return CURLE_OK;
}

/*
 * Curl_base64_encode()
 *
 * Given a pointer to an input buffer and an input size, encode it and
 * return a pointer in *outptr to a newly allocated memory area holding
 * encoded data. Size of encoded data is returned in variable pointed by
 * outlen.
 *
 * Input length of 0 indicates input buffer holds a NUL-terminated string.
 *
 * Returns CURLE_OK on success, otherwise specific error code. Function
 * output shall not be considered valid unless CURLE_OK is returned.
 *
 * When encoded data length is 0, returns NULL in *outptr.
 *
 * @unittest: 1302
 */
CURLcode Curl_base64_encode(struct Curl_easy *data,
                            const char *inputbuff, size_t insize,
                            char **outptr, size_t *outlen)
{
  return base64_encode(base64, data, inputbuff, insize, outptr, outlen);
}

/*
 * Curl_base64url_encode()
 *
 * Given a pointer to an input buffer and an input size, encode it and
 * return a pointer in *outptr to a newly allocated memory area holding
 * encoded data. Size of encoded data is returned in variable pointed by
 * outlen.
 *
 * Input length of 0 indicates input buffer holds a NUL-terminated string.
 *
 * Returns CURLE_OK on success, otherwise specific error code. Function
 * output shall not be considered valid unless CURLE_OK is returned.
 *
 * When encoded data length is 0, returns NULL in *outptr.
 *
 * @unittest: 1302
 */
CURLcode Curl_base64url_encode(struct Curl_easy *data,
                               const char *inputbuff, size_t insize,
                               char **outptr, size_t *outlen)
{
  return base64_encode(base64url, data, inputbuff, insize, outptr, outlen);
}

1	/***************************************************************************
2	* _ _ ____ _
3	* Project ___\| \| \| \| _ \\| \|
4	* / __\| \| \| \| \|_) \| \|
5	* \| (__\| \|_\| \| _ <\| \|___
6	* \___\|\___/\|_\| \_\_____\|
7	*
8	* Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
9	*
10	* This software is licensed as described in the file COPYING, which
11	* you should have received as part of this distribution. The terms
12	* are also available at https://curl.haxx.se/docs/copyright.html.
13	*
14	* You may opt to use, copy, modify, merge, publish, distribute and/or sell
15	* copies of the Software, and permit persons to whom the Software is
16	* furnished to do so, under the terms of the COPYING file.
17	*
18	* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19	* KIND, either express or implied.
20	*
21	***************************************************************************/
22
23	/* Base64 encoding/decoding */
24
25	#include "curl_setup.h"
26	#include "urldata.h" /* for the Curl_easy definition */
27	#include "warnless.h"
28	#include "curl_base64.h"
29	#include "non-ascii.h"
30
31	/* The last 3 #include files should be in this order */
32	#include "curl_printf.h"
33	#include "curl_memory.h"
34	#include "memdebug.h"
35
36	/* ---- Base64 Encoding/Decoding Table --- */
37	static const char base64[]=
38	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
39
40	/* The Base 64 encoding with an URL and filename safe alphabet, RFC 4648
41	section 5 */
42	static const char base64url[]=
43	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
44
45	static size_t decodeQuantum(unsigned char dest, const char src)	11,185✔
46	{
47	size_t padding = 0;	11,185✔
48	const char s, p;
49	unsigned long i, x = 0;	11,185✔
50
51	for(i = 0, s = src; i < 4; i++, s++) {	55,925✔
52	if(*s == '=') {	44,740✔
53	x = (x << 6);	415✔
54	padding++;	415✔
55	}
56	else {
57	unsigned long v = 0;	44,325✔
58	p = base64;	44,325✔
59
60	while(p && (p != *s)) {	658,392✔
61	v++;	569,742✔
62	p++;	569,742✔
63	}
64
65	if(p == s)	44,325✔
66	x = (x << 6) + v;	44,325✔
67	else
68	return 0;	×
69	}
70	}
71
72	if(padding < 1)	11,185✔
73	dest[2] = curlx_ultouc(x & 0xFFUL);	10,970✔
74
75	x >>= 8;	11,185✔
76	if(padding < 2)	11,185✔
77	dest[1] = curlx_ultouc(x & 0xFFUL);	10,985✔
78
79	x >>= 8;	11,185✔
80	dest[0] = curlx_ultouc(x & 0xFFUL);	11,185✔
81
82	return 3 - padding;	11,185✔
83	}
84
85	/*
86	* Curl_base64_decode()
87	*
88	* Given a base64 NUL-terminated string at src, decode it and return a
89	* pointer in *outptr to a newly allocated memory area holding decoded
90	* data. Size of decoded data is returned in variable pointed by outlen.
91	*
92	* Returns CURLE_OK on success, otherwise specific error code. Function
93	* output shall not be considered valid unless CURLE_OK is returned.
94	*
95	* When decoded data length is 0, returns NULL in *outptr.
96	*
97	* @unittest: 1302
98	*/
99	CURLcode Curl_base64_decode(const char *src,	259✔
100	unsigned char *outptr, size_t outlen)
101	{
102	size_t srclen = 0;	259✔
103	size_t length = 0;	259✔
104	size_t padding = 0;	259✔
105	size_t i;
106	size_t numQuantums;
107	size_t rawlen = 0;	259✔
108	unsigned char *pos;
109	unsigned char *newstr;
110
111	*outptr = NULL;	259✔
112	*outlen = 0;	259✔
113	srclen = strlen(src);	259✔
114
115	/* Check the length of the input string is valid */
116	if(!srclen \|\| srclen % 4)	259✔
117	return CURLE_BAD_CONTENT_ENCODING;	36✔
118
119	/* Find the position of any = padding characters */
120	while((src[length] != '=') && src[length])	44,771✔
121	length++;	44,325✔
122
123	/* A maximum of two = padding characters is allowed */
124	if(src[length] == '=') {	223✔
125	padding++;	215✔
126	if(src[length + 1] == '=')	215✔
127	padding++;	200✔
128	}
129
130	/* Check the = padding characters weren't part way through the input */
131	if(length + padding != srclen)	223✔
132	return CURLE_BAD_CONTENT_ENCODING;	×
133
134	/* Calculate the number of quantums */
135	numQuantums = srclen / 4;	223✔
136
137	/* Calculate the size of the decoded string */
138	rawlen = (numQuantums * 3) - padding;	223✔
139
140	/* Allocate our buffer including room for a zero terminator */
141	newstr = malloc(rawlen + 1);	223✔
142	if(!newstr)	223✔
143	return CURLE_OUT_OF_MEMORY;	×
144
145	pos = newstr;	223✔
146
147	/* Decode the quantums */
148	for(i = 0; i < numQuantums; i++) {	11,408✔
149	size_t result = decodeQuantum(pos, src);	11,185✔
150	if(!result) {	11,185✔
151	free(newstr);	×
152
153	return CURLE_BAD_CONTENT_ENCODING;	×
154	}
155
156	pos += result;	11,185✔
157	src += 4;	11,185✔
158	}
159
160	/* Zero terminate */
161	*pos = '\0';	223✔
162
163	/* Return the decoded data */
164	*outptr = newstr;	223✔
165	*outlen = rawlen;	223✔
166
167	return CURLE_OK;	223✔
168	}
169
170	static CURLcode base64_encode(const char *table64,	1,438✔
171	struct Curl_easy *data,
172	const char *inputbuff, size_t insize,
173	char *outptr, size_t outlen)
174	{
175	CURLcode result;
176	unsigned char ibuf[3];
177	unsigned char obuf[4];
178	int i;
179	int inputparts;
180	char *output;
181	char *base64data;
182	char *convbuf = NULL;	1,438✔
183
184	const char *indata = inputbuff;	1,438✔
185
186	*outptr = NULL;	1,438✔
187	*outlen = 0;	1,438✔
188
189	if(!insize)	1,438✔
190	insize = strlen(indata);	14✔
191
192	#if SIZEOF_SIZE_T == 4
193	if(insize > UINT_MAX/4)
194	return CURLE_OUT_OF_MEMORY;
195	#endif
196
197	base64data = output = malloc(insize * 4 / 3 + 4);	1,438✔
198	if(!output)	1,438✔
199	return CURLE_OUT_OF_MEMORY;	17✔
200
201	/*
202	* The base64 data needs to be created using the network encoding
203	* not the host encoding. And we can't change the actual input
204	* so we copy it to a buffer, translate it, and use that instead.
205	*/
206	result = Curl_convert_clone(data, indata, insize, &convbuf);	1,421✔
207	if(result) {	1,421✔
208	free(output);	×
209	return result;	×
210	}
211
212	if(convbuf)	1,421✔
213	indata = (char *)convbuf;	×
214
215	while(insize > 0) {	28,815✔
216	for(i = inputparts = 0; i < 3; i++) {	103,892✔
217	if(insize > 0) {	77,919✔
218	inputparts++;	76,344✔
219	ibuf[i] = (unsigned char) *indata;	76,344✔
220	indata++;	76,344✔
221	insize--;	76,344✔
222	}
223	else
224	ibuf[i] = 0;	1,575✔
225	}
226
227	obuf[0] = (unsigned char) ((ibuf[0] & 0xFC) >> 2);	25,973✔
228	obuf[1] = (unsigned char) (((ibuf[0] & 0x03) << 4) \| \	51,946✔
229	((ibuf[1] & 0xF0) >> 4));	25,973✔
230	obuf[2] = (unsigned char) (((ibuf[1] & 0x0F) << 2) \| \	51,946✔
231	((ibuf[2] & 0xC0) >> 6));	25,973✔
232	obuf[3] = (unsigned char) (ibuf[2] & 0x3F);	25,973✔
233
234	switch(inputparts) {	25,973✔
235	case 1: /* only one byte read */	434✔
236	snprintf(output, 5, "%c%c==",	868✔
237	table64[obuf[0]],	434✔
238	table64[obuf[1]]);	434✔
239	break;	434✔
240
241	case 2: /* two bytes read */	707✔
242	snprintf(output, 5, "%c%c%c=",	2,121✔
243	table64[obuf[0]],	707✔
244	table64[obuf[1]],	707✔
245	table64[obuf[2]]);	707✔
246	break;	707✔
247
248	default:	24,832✔
249	snprintf(output, 5, "%c%c%c%c",	99,328✔
250	table64[obuf[0]],	24,832✔
251	table64[obuf[1]],	24,832✔
252	table64[obuf[2]],	24,832✔
253	table64[obuf[3]]);	24,832✔
254	break;	24,832✔
255	}
256	output += 4;	25,973✔
257	}
258
259	/* Zero terminate */
260	*output = '\0';	1,421✔
261
262	/* Return the pointer to the new data (allocated memory) */
263	*outptr = base64data;	1,421✔
264
265	free(convbuf);	1,421✔
266
267	/* Return the length of the new data */
268	*outlen = strlen(base64data);	1,421✔
269
270	return CURLE_OK;	1,421✔
271	}
272
273	/*
274	* Curl_base64_encode()
275	*
276	* Given a pointer to an input buffer and an input size, encode it and
277	* return a pointer in *outptr to a newly allocated memory area holding
278	* encoded data. Size of encoded data is returned in variable pointed by
279	* outlen.
280	*
281	* Input length of 0 indicates input buffer holds a NUL-terminated string.
282	*
283	* Returns CURLE_OK on success, otherwise specific error code. Function
284	* output shall not be considered valid unless CURLE_OK is returned.
285	*
286	* When encoded data length is 0, returns NULL in *outptr.
287	*
288	* @unittest: 1302
289	*/
290	CURLcode Curl_base64_encode(struct Curl_easy *data,	1,430✔
291	const char *inputbuff, size_t insize,
292	char *outptr, size_t outlen)
293	{
294	return base64_encode(base64, data, inputbuff, insize, outptr, outlen);	1,430✔
295	}
296
297	/*
298	* Curl_base64url_encode()
299	*
300	* Given a pointer to an input buffer and an input size, encode it and
301	* return a pointer in *outptr to a newly allocated memory area holding
302	* encoded data. Size of encoded data is returned in variable pointed by
303	* outlen.
304	*
305	* Input length of 0 indicates input buffer holds a NUL-terminated string.
306	*
307	* Returns CURLE_OK on success, otherwise specific error code. Function
308	* output shall not be considered valid unless CURLE_OK is returned.
309	*
310	* When encoded data length is 0, returns NULL in *outptr.
311	*
312	* @unittest: 1302
313	*/
314	CURLcode Curl_base64url_encode(struct Curl_easy *data,	8✔
315	const char *inputbuff, size_t insize,
316	char *outptr, size_t outlen)
317	{
318	return base64_encode(base64url, data, inputbuff, insize, outptr, outlen);	8✔
319	}

curl / curl / 9253

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous