1/*************************************************************************** 2 * _ _ ____ _ 3 * Project ___| | | | _ \| | 4 * / __| | | | |_) | | 5 * | (__| |_| | _ <| |___ 6 * \___|\___/|_| \_\_____| 7 * 8 * Copyright (C) 1998 - 2014, 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 http://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#include "curl_setup.h" 24 25#if defined(__INTEL_COMPILER) && defined(__unix__) 26 27#ifdef HAVE_NETINET_IN_H 28# include <netinet/in.h> 29#endif 30#ifdef HAVE_ARPA_INET_H 31# include <arpa/inet.h> 32#endif 33 34#endif /* __INTEL_COMPILER && __unix__ */ 35 36#define BUILDING_WARNLESS_C 1 37 38#include "warnless.h" 39 40#define CURL_MASK_SCHAR 0x7F 41#define CURL_MASK_UCHAR 0xFF 42 43#if (SIZEOF_SHORT == 2) 44# define CURL_MASK_SSHORT 0x7FFF 45# define CURL_MASK_USHORT 0xFFFF 46#elif (SIZEOF_SHORT == 4) 47# define CURL_MASK_SSHORT 0x7FFFFFFF 48# define CURL_MASK_USHORT 0xFFFFFFFF 49#elif (SIZEOF_SHORT == 8) 50# define CURL_MASK_SSHORT 0x7FFFFFFFFFFFFFFF 51# define CURL_MASK_USHORT 0xFFFFFFFFFFFFFFFF 52#else 53# error "SIZEOF_SHORT not defined" 54#endif 55 56#if (SIZEOF_INT == 2) 57# define CURL_MASK_SINT 0x7FFF 58# define CURL_MASK_UINT 0xFFFF 59#elif (SIZEOF_INT == 4) 60# define CURL_MASK_SINT 0x7FFFFFFF 61# define CURL_MASK_UINT 0xFFFFFFFF 62#elif (SIZEOF_INT == 8) 63# define CURL_MASK_SINT 0x7FFFFFFFFFFFFFFF 64# define CURL_MASK_UINT 0xFFFFFFFFFFFFFFFF 65#elif (SIZEOF_INT == 16) 66# define CURL_MASK_SINT 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF 67# define CURL_MASK_UINT 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF 68#else 69# error "SIZEOF_INT not defined" 70#endif 71 72#if (CURL_SIZEOF_LONG == 2) 73# define CURL_MASK_SLONG 0x7FFFL 74# define CURL_MASK_ULONG 0xFFFFUL 75#elif (CURL_SIZEOF_LONG == 4) 76# define CURL_MASK_SLONG 0x7FFFFFFFL 77# define CURL_MASK_ULONG 0xFFFFFFFFUL 78#elif (CURL_SIZEOF_LONG == 8) 79# define CURL_MASK_SLONG 0x7FFFFFFFFFFFFFFFL 80# define CURL_MASK_ULONG 0xFFFFFFFFFFFFFFFFUL 81#elif (CURL_SIZEOF_LONG == 16) 82# define CURL_MASK_SLONG 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFL 83# define CURL_MASK_ULONG 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFUL 84#else 85# error "CURL_SIZEOF_LONG not defined" 86#endif 87 88#if (CURL_SIZEOF_CURL_OFF_T == 2) 89# define CURL_MASK_SCOFFT CURL_OFF_T_C(0x7FFF) 90# define CURL_MASK_UCOFFT CURL_OFF_TU_C(0xFFFF) 91#elif (CURL_SIZEOF_CURL_OFF_T == 4) 92# define CURL_MASK_SCOFFT CURL_OFF_T_C(0x7FFFFFFF) 93# define CURL_MASK_UCOFFT CURL_OFF_TU_C(0xFFFFFFFF) 94#elif (CURL_SIZEOF_CURL_OFF_T == 8) 95# define CURL_MASK_SCOFFT CURL_OFF_T_C(0x7FFFFFFFFFFFFFFF) 96# define CURL_MASK_UCOFFT CURL_OFF_TU_C(0xFFFFFFFFFFFFFFFF) 97#elif (CURL_SIZEOF_CURL_OFF_T == 16) 98# define CURL_MASK_SCOFFT CURL_OFF_T_C(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) 99# define CURL_MASK_UCOFFT CURL_OFF_TU_C(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) 100#else 101# error "CURL_SIZEOF_CURL_OFF_T not defined" 102#endif 103 104#if (SIZEOF_SIZE_T == SIZEOF_SHORT) 105# define CURL_MASK_SSIZE_T CURL_MASK_SSHORT 106# define CURL_MASK_USIZE_T CURL_MASK_USHORT 107#elif (SIZEOF_SIZE_T == SIZEOF_INT) 108# define CURL_MASK_SSIZE_T CURL_MASK_SINT 109# define CURL_MASK_USIZE_T CURL_MASK_UINT 110#elif (SIZEOF_SIZE_T == CURL_SIZEOF_LONG) 111# define CURL_MASK_SSIZE_T CURL_MASK_SLONG 112# define CURL_MASK_USIZE_T CURL_MASK_ULONG 113#elif (SIZEOF_SIZE_T == CURL_SIZEOF_CURL_OFF_T) 114# define CURL_MASK_SSIZE_T CURL_MASK_SCOFFT 115# define CURL_MASK_USIZE_T CURL_MASK_UCOFFT 116#else 117# error "SIZEOF_SIZE_T not defined" 118#endif 119 120/* 121** unsigned long to unsigned short 122*/ 123 124unsigned short curlx_ultous(unsigned long ulnum) 125{ 126#ifdef __INTEL_COMPILER 127# pragma warning(push) 128# pragma warning(disable:810) /* conversion may lose significant bits */ 129#endif 130 131 DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_USHORT); 132 return (unsigned short)(ulnum & (unsigned long) CURL_MASK_USHORT); 133 134#ifdef __INTEL_COMPILER 135# pragma warning(pop) 136#endif 137} 138 139/* 140** unsigned long to unsigned char 141*/ 142 143unsigned char curlx_ultouc(unsigned long ulnum) 144{ 145#ifdef __INTEL_COMPILER 146# pragma warning(push) 147# pragma warning(disable:810) /* conversion may lose significant bits */ 148#endif 149 150 DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_UCHAR); 151 return (unsigned char)(ulnum & (unsigned long) CURL_MASK_UCHAR); 152 153#ifdef __INTEL_COMPILER 154# pragma warning(pop) 155#endif 156} 157 158/* 159** unsigned long to signed int 160*/ 161 162int curlx_ultosi(unsigned long ulnum) 163{ 164#ifdef __INTEL_COMPILER 165# pragma warning(push) 166# pragma warning(disable:810) /* conversion may lose significant bits */ 167#endif 168 169 DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_SINT); 170 return (int)(ulnum & (unsigned long) CURL_MASK_SINT); 171 172#ifdef __INTEL_COMPILER 173# pragma warning(pop) 174#endif 175} 176 177/* 178** unsigned size_t to signed curl_off_t 179*/ 180 181curl_off_t curlx_uztoso(size_t uznum) 182{ 183#ifdef __INTEL_COMPILER 184# pragma warning(push) 185# pragma warning(disable:810) /* conversion may lose significant bits */ 186#endif 187 188 DEBUGASSERT(uznum <= (size_t) CURL_MASK_SCOFFT); 189 return (curl_off_t)(uznum & (size_t) CURL_MASK_SCOFFT); 190 191#ifdef __INTEL_COMPILER 192# pragma warning(pop) 193#endif 194} 195 196/* 197** unsigned size_t to signed int 198*/ 199 200int curlx_uztosi(size_t uznum) 201{ 202#ifdef __INTEL_COMPILER 203# pragma warning(push) 204# pragma warning(disable:810) /* conversion may lose significant bits */ 205#endif 206 207 DEBUGASSERT(uznum <= (size_t) CURL_MASK_SINT); 208 return (int)(uznum & (size_t) CURL_MASK_SINT); 209 210#ifdef __INTEL_COMPILER 211# pragma warning(pop) 212#endif 213} 214 215/* 216** unsigned size_t to unsigned long 217*/ 218 219unsigned long curlx_uztoul(size_t uznum) 220{ 221#ifdef __INTEL_COMPILER 222# pragma warning(push) 223# pragma warning(disable:810) /* conversion may lose significant bits */ 224#endif 225 226#if (CURL_SIZEOF_LONG < SIZEOF_SIZE_T) 227 DEBUGASSERT(uznum <= (size_t) CURL_MASK_ULONG); 228#endif 229 return (unsigned long)(uznum & (size_t) CURL_MASK_ULONG); 230 231#ifdef __INTEL_COMPILER 232# pragma warning(pop) 233#endif 234} 235 236/* 237** unsigned size_t to unsigned int 238*/ 239 240unsigned int curlx_uztoui(size_t uznum) 241{ 242#ifdef __INTEL_COMPILER 243# pragma warning(push) 244# pragma warning(disable:810) /* conversion may lose significant bits */ 245#endif 246 247#if (SIZEOF_INT < SIZEOF_SIZE_T) 248 DEBUGASSERT(uznum <= (size_t) CURL_MASK_UINT); 249#endif 250 return (unsigned int)(uznum & (size_t) CURL_MASK_UINT); 251 252#ifdef __INTEL_COMPILER 253# pragma warning(pop) 254#endif 255} 256 257/* 258** signed long to signed int 259*/ 260 261int curlx_sltosi(long slnum) 262{ 263#ifdef __INTEL_COMPILER 264# pragma warning(push) 265# pragma warning(disable:810) /* conversion may lose significant bits */ 266#endif 267 268 DEBUGASSERT(slnum >= 0); 269#if (SIZEOF_INT < CURL_SIZEOF_LONG) 270 DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_SINT); 271#endif 272 return (int)(slnum & (long) CURL_MASK_SINT); 273 274#ifdef __INTEL_COMPILER 275# pragma warning(pop) 276#endif 277} 278 279/* 280** signed long to unsigned int 281*/ 282 283unsigned int curlx_sltoui(long slnum) 284{ 285#ifdef __INTEL_COMPILER 286# pragma warning(push) 287# pragma warning(disable:810) /* conversion may lose significant bits */ 288#endif 289 290 DEBUGASSERT(slnum >= 0); 291#if (SIZEOF_INT < CURL_SIZEOF_LONG) 292 DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_UINT); 293#endif 294 return (unsigned int)(slnum & (long) CURL_MASK_UINT); 295 296#ifdef __INTEL_COMPILER 297# pragma warning(pop) 298#endif 299} 300 301/* 302** signed long to unsigned short 303*/ 304 305unsigned short curlx_sltous(long slnum) 306{ 307#ifdef __INTEL_COMPILER 308# pragma warning(push) 309# pragma warning(disable:810) /* conversion may lose significant bits */ 310#endif 311 312 DEBUGASSERT(slnum >= 0); 313 DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_USHORT); 314 return (unsigned short)(slnum & (long) CURL_MASK_USHORT); 315 316#ifdef __INTEL_COMPILER 317# pragma warning(pop) 318#endif 319} 320 321/* 322** unsigned size_t to signed ssize_t 323*/ 324 325ssize_t curlx_uztosz(size_t uznum) 326{ 327#ifdef __INTEL_COMPILER 328# pragma warning(push) 329# pragma warning(disable:810) /* conversion may lose significant bits */ 330#endif 331 332 DEBUGASSERT(uznum <= (size_t) CURL_MASK_SSIZE_T); 333 return (ssize_t)(uznum & (size_t) CURL_MASK_SSIZE_T); 334 335#ifdef __INTEL_COMPILER 336# pragma warning(pop) 337#endif 338} 339 340/* 341** signed curl_off_t to unsigned size_t 342*/ 343 344size_t curlx_sotouz(curl_off_t sonum) 345{ 346#ifdef __INTEL_COMPILER 347# pragma warning(push) 348# pragma warning(disable:810) /* conversion may lose significant bits */ 349#endif 350 351 DEBUGASSERT(sonum >= 0); 352 return (size_t)(sonum & (curl_off_t) CURL_MASK_USIZE_T); 353 354#ifdef __INTEL_COMPILER 355# pragma warning(pop) 356#endif 357} 358 359/* 360** signed ssize_t to signed int 361*/ 362 363int curlx_sztosi(ssize_t sznum) 364{ 365#ifdef __INTEL_COMPILER 366# pragma warning(push) 367# pragma warning(disable:810) /* conversion may lose significant bits */ 368#endif 369 370 DEBUGASSERT(sznum >= 0); 371#if (SIZEOF_INT < SIZEOF_SIZE_T) 372 DEBUGASSERT((size_t) sznum <= (size_t) CURL_MASK_SINT); 373#endif 374 return (int)(sznum & (ssize_t) CURL_MASK_SINT); 375 376#ifdef __INTEL_COMPILER 377# pragma warning(pop) 378#endif 379} 380 381/* 382** signed int to unsigned size_t 383*/ 384 385size_t curlx_sitouz(int sinum) 386{ 387#ifdef __INTEL_COMPILER 388# pragma warning(push) 389# pragma warning(disable:810) /* conversion may lose significant bits */ 390#endif 391 392 DEBUGASSERT(sinum >= 0); 393 return (size_t) sinum; 394 395#ifdef __INTEL_COMPILER 396# pragma warning(pop) 397#endif 398} 399 400#ifdef USE_WINSOCK 401 402/* 403** curl_socket_t to signed int 404*/ 405 406int curlx_sktosi(curl_socket_t s) 407{ 408 return (int)((ssize_t) s); 409} 410 411/* 412** signed int to curl_socket_t 413*/ 414 415curl_socket_t curlx_sitosk(int i) 416{ 417 return (curl_socket_t)((ssize_t) i); 418} 419 420#endif /* USE_WINSOCK */ 421 422#if defined(WIN32) || defined(_WIN32) 423 424ssize_t curlx_read(int fd, void *buf, size_t count) 425{ 426 return (ssize_t)read(fd, buf, curlx_uztoui(count)); 427} 428 429ssize_t curlx_write(int fd, const void *buf, size_t count) 430{ 431 return (ssize_t)write(fd, buf, curlx_uztoui(count)); 432} 433 434#endif /* WIN32 || _WIN32 */ 435 436#if defined(__INTEL_COMPILER) && defined(__unix__) 437 438int curlx_FD_ISSET(int fd, fd_set *fdset) 439{ 440 #pragma warning(push) 441 #pragma warning(disable:1469) /* clobber ignored */ 442 return FD_ISSET(fd, fdset); 443 #pragma warning(pop) 444} 445 446void curlx_FD_SET(int fd, fd_set *fdset) 447{ 448 #pragma warning(push) 449 #pragma warning(disable:1469) /* clobber ignored */ 450 FD_SET(fd, fdset); 451 #pragma warning(pop) 452} 453 454void curlx_FD_ZERO(fd_set *fdset) 455{ 456 #pragma warning(push) 457 #pragma warning(disable:593) /* variable was set but never used */ 458 FD_ZERO(fdset); 459 #pragma warning(pop) 460} 461 462unsigned short curlx_htons(unsigned short usnum) 463{ 464#if (__INTEL_COMPILER == 910) && defined(__i386__) 465 return (unsigned short)(((usnum << 8) & 0xFF00) | ((usnum >> 8) & 0x00FF)); 466#else 467 #pragma warning(push) 468 #pragma warning(disable:810) /* conversion may lose significant bits */ 469 return htons(usnum); 470 #pragma warning(pop) 471#endif 472} 473 474unsigned short curlx_ntohs(unsigned short usnum) 475{ 476#if (__INTEL_COMPILER == 910) && defined(__i386__) 477 return (unsigned short)(((usnum << 8) & 0xFF00) | ((usnum >> 8) & 0x00FF)); 478#else 479 #pragma warning(push) 480 #pragma warning(disable:810) /* conversion may lose significant bits */ 481 return ntohs(usnum); 482 #pragma warning(pop) 483#endif 484} 485 486#endif /* __INTEL_COMPILER && __unix__ */ 487