1 /*************************************************************************** 2 * _ _ ____ _ 3 * Project ___| | | | _ \| | 4 * / __| | | | |_) | | 5 * | (__| |_| | _ <| |___ 6 * \___|\___/|_| \_\_____| 7 * 8 * Copyright (C) 1998 - 2019, Daniel Stenberg, <daniel (at) 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 #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 (SIZEOF_LONG == 2) 73 # define CURL_MASK_SLONG 0x7FFFL 74 # define CURL_MASK_ULONG 0xFFFFUL 75 #elif (SIZEOF_LONG == 4) 76 # define CURL_MASK_SLONG 0x7FFFFFFFL 77 # define CURL_MASK_ULONG 0xFFFFFFFFUL 78 #elif (SIZEOF_LONG == 8) 79 # define CURL_MASK_SLONG 0x7FFFFFFFFFFFFFFFL 80 # define CURL_MASK_ULONG 0xFFFFFFFFFFFFFFFFUL 81 #elif (SIZEOF_LONG == 16) 82 # define CURL_MASK_SLONG 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFL 83 # define CURL_MASK_ULONG 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFUL 84 #else 85 # error "SIZEOF_LONG not defined" 86 #endif 87 88 #if (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 (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 (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 (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 "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 == 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 == 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 124 unsigned 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 143 unsigned 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 162 int 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 181 curl_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 #elif defined(_MSC_VER) 187 # pragma warning(push) 188 # pragma warning(disable:4310) /* cast truncates constant value */ 189 #endif 190 191 DEBUGASSERT(uznum <= (size_t) CURL_MASK_SCOFFT); 192 return (curl_off_t)(uznum & (size_t) CURL_MASK_SCOFFT); 193 194 #if defined(__INTEL_COMPILER) || defined(_MSC_VER) 195 # pragma warning(pop) 196 #endif 197 } 198 199 /* 200 ** unsigned size_t to signed int 201 */ 202 203 int curlx_uztosi(size_t uznum) 204 { 205 #ifdef __INTEL_COMPILER 206 # pragma warning(push) 207 # pragma warning(disable:810) /* conversion may lose significant bits */ 208 #endif 209 210 DEBUGASSERT(uznum <= (size_t) CURL_MASK_SINT); 211 return (int)(uznum & (size_t) CURL_MASK_SINT); 212 213 #ifdef __INTEL_COMPILER 214 # pragma warning(pop) 215 #endif 216 } 217 218 /* 219 ** unsigned size_t to unsigned long 220 */ 221 222 unsigned long curlx_uztoul(size_t uznum) 223 { 224 #ifdef __INTEL_COMPILER 225 # pragma warning(push) 226 # pragma warning(disable:810) /* conversion may lose significant bits */ 227 #endif 228 229 #if (SIZEOF_LONG < SIZEOF_SIZE_T) 230 DEBUGASSERT(uznum <= (size_t) CURL_MASK_ULONG); 231 #endif 232 return (unsigned long)(uznum & (size_t) CURL_MASK_ULONG); 233 234 #ifdef __INTEL_COMPILER 235 # pragma warning(pop) 236 #endif 237 } 238 239 /* 240 ** unsigned size_t to unsigned int 241 */ 242 243 unsigned int curlx_uztoui(size_t uznum) 244 { 245 #ifdef __INTEL_COMPILER 246 # pragma warning(push) 247 # pragma warning(disable:810) /* conversion may lose significant bits */ 248 #endif 249 250 #if (SIZEOF_INT < SIZEOF_SIZE_T) 251 DEBUGASSERT(uznum <= (size_t) CURL_MASK_UINT); 252 #endif 253 return (unsigned int)(uznum & (size_t) CURL_MASK_UINT); 254 255 #ifdef __INTEL_COMPILER 256 # pragma warning(pop) 257 #endif 258 } 259 260 /* 261 ** signed long to signed int 262 */ 263 264 int curlx_sltosi(long slnum) 265 { 266 #ifdef __INTEL_COMPILER 267 # pragma warning(push) 268 # pragma warning(disable:810) /* conversion may lose significant bits */ 269 #endif 270 271 DEBUGASSERT(slnum >= 0); 272 #if (SIZEOF_INT < SIZEOF_LONG) 273 DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_SINT); 274 #endif 275 return (int)(slnum & (long) CURL_MASK_SINT); 276 277 #ifdef __INTEL_COMPILER 278 # pragma warning(pop) 279 #endif 280 } 281 282 /* 283 ** signed long to unsigned int 284 */ 285 286 unsigned int curlx_sltoui(long slnum) 287 { 288 #ifdef __INTEL_COMPILER 289 # pragma warning(push) 290 # pragma warning(disable:810) /* conversion may lose significant bits */ 291 #endif 292 293 DEBUGASSERT(slnum >= 0); 294 #if (SIZEOF_INT < SIZEOF_LONG) 295 DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_UINT); 296 #endif 297 return (unsigned int)(slnum & (long) CURL_MASK_UINT); 298 299 #ifdef __INTEL_COMPILER 300 # pragma warning(pop) 301 #endif 302 } 303 304 /* 305 ** signed long to unsigned short 306 */ 307 308 unsigned short curlx_sltous(long slnum) 309 { 310 #ifdef __INTEL_COMPILER 311 # pragma warning(push) 312 # pragma warning(disable:810) /* conversion may lose significant bits */ 313 #endif 314 315 DEBUGASSERT(slnum >= 0); 316 DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_USHORT); 317 return (unsigned short)(slnum & (long) CURL_MASK_USHORT); 318 319 #ifdef __INTEL_COMPILER 320 # pragma warning(pop) 321 #endif 322 } 323 324 /* 325 ** unsigned size_t to signed ssize_t 326 */ 327 328 ssize_t curlx_uztosz(size_t uznum) 329 { 330 #ifdef __INTEL_COMPILER 331 # pragma warning(push) 332 # pragma warning(disable:810) /* conversion may lose significant bits */ 333 #endif 334 335 DEBUGASSERT(uznum <= (size_t) CURL_MASK_SSIZE_T); 336 return (ssize_t)(uznum & (size_t) CURL_MASK_SSIZE_T); 337 338 #ifdef __INTEL_COMPILER 339 # pragma warning(pop) 340 #endif 341 } 342 343 /* 344 ** signed curl_off_t to unsigned size_t 345 */ 346 347 size_t curlx_sotouz(curl_off_t sonum) 348 { 349 #ifdef __INTEL_COMPILER 350 # pragma warning(push) 351 # pragma warning(disable:810) /* conversion may lose significant bits */ 352 #endif 353 354 DEBUGASSERT(sonum >= 0); 355 return (size_t)(sonum & (curl_off_t) CURL_MASK_USIZE_T); 356 357 #ifdef __INTEL_COMPILER 358 # pragma warning(pop) 359 #endif 360 } 361 362 /* 363 ** signed ssize_t to signed int 364 */ 365 366 int curlx_sztosi(ssize_t sznum) 367 { 368 #ifdef __INTEL_COMPILER 369 # pragma warning(push) 370 # pragma warning(disable:810) /* conversion may lose significant bits */ 371 #endif 372 373 DEBUGASSERT(sznum >= 0); 374 #if (SIZEOF_INT < SIZEOF_SIZE_T) 375 DEBUGASSERT((size_t) sznum <= (size_t) CURL_MASK_SINT); 376 #endif 377 return (int)(sznum & (ssize_t) CURL_MASK_SINT); 378 379 #ifdef __INTEL_COMPILER 380 # pragma warning(pop) 381 #endif 382 } 383 384 /* 385 ** unsigned int to unsigned short 386 */ 387 388 unsigned short curlx_uitous(unsigned int uinum) 389 { 390 #ifdef __INTEL_COMPILER 391 # pragma warning(push) 392 # pragma warning(disable:810) /* conversion may lose significant bits */ 393 #endif 394 395 DEBUGASSERT(uinum <= (unsigned int) CURL_MASK_USHORT); 396 return (unsigned short) (uinum & (unsigned int) CURL_MASK_USHORT); 397 398 #ifdef __INTEL_COMPILER 399 # pragma warning(pop) 400 #endif 401 } 402 403 /* 404 ** signed int to unsigned size_t 405 */ 406 407 size_t curlx_sitouz(int sinum) 408 { 409 #ifdef __INTEL_COMPILER 410 # pragma warning(push) 411 # pragma warning(disable:810) /* conversion may lose significant bits */ 412 #endif 413 414 DEBUGASSERT(sinum >= 0); 415 return (size_t) sinum; 416 417 #ifdef __INTEL_COMPILER 418 # pragma warning(pop) 419 #endif 420 } 421 422 #ifdef USE_WINSOCK 423 424 /* 425 ** curl_socket_t to signed int 426 */ 427 428 int curlx_sktosi(curl_socket_t s) 429 { 430 return (int)((ssize_t) s); 431 } 432 433 /* 434 ** signed int to curl_socket_t 435 */ 436 437 curl_socket_t curlx_sitosk(int i) 438 { 439 return (curl_socket_t)((ssize_t) i); 440 } 441 442 #endif /* USE_WINSOCK */ 443 444 #if defined(WIN32) || defined(_WIN32) 445 446 ssize_t curlx_read(int fd, void *buf, size_t count) 447 { 448 return (ssize_t)read(fd, buf, curlx_uztoui(count)); 449 } 450 451 ssize_t curlx_write(int fd, const void *buf, size_t count) 452 { 453 return (ssize_t)write(fd, buf, curlx_uztoui(count)); 454 } 455 456 #endif /* WIN32 || _WIN32 */ 457 458 #if defined(__INTEL_COMPILER) && defined(__unix__) 459 460 int curlx_FD_ISSET(int fd, fd_set *fdset) 461 { 462 #pragma warning(push) 463 #pragma warning(disable:1469) /* clobber ignored */ 464 return FD_ISSET(fd, fdset); 465 #pragma warning(pop) 466 } 467 468 void curlx_FD_SET(int fd, fd_set *fdset) 469 { 470 #pragma warning(push) 471 #pragma warning(disable:1469) /* clobber ignored */ 472 FD_SET(fd, fdset); 473 #pragma warning(pop) 474 } 475 476 void curlx_FD_ZERO(fd_set *fdset) 477 { 478 #pragma warning(push) 479 #pragma warning(disable:593) /* variable was set but never used */ 480 FD_ZERO(fdset); 481 #pragma warning(pop) 482 } 483 484 unsigned short curlx_htons(unsigned short usnum) 485 { 486 #if (__INTEL_COMPILER == 910) && defined(__i386__) 487 return (unsigned short)(((usnum << 8) & 0xFF00) | ((usnum >> 8) & 0x00FF)); 488 #else 489 #pragma warning(push) 490 #pragma warning(disable:810) /* conversion may lose significant bits */ 491 return htons(usnum); 492 #pragma warning(pop) 493 #endif 494 } 495 496 unsigned short curlx_ntohs(unsigned short usnum) 497 { 498 #if (__INTEL_COMPILER == 910) && defined(__i386__) 499 return (unsigned short)(((usnum << 8) & 0xFF00) | ((usnum >> 8) & 0x00FF)); 500 #else 501 #pragma warning(push) 502 #pragma warning(disable:810) /* conversion may lose significant bits */ 503 return ntohs(usnum); 504 #pragma warning(pop) 505 #endif 506 } 507 508 #endif /* __INTEL_COMPILER && __unix__ */ 509
