Home | History | Annotate | Download | only in lib
      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