| Wireshark 4.7.3 The Wireshark network protocol analyzer

Loading...
Searching...
No Matches
Functions
strtoi.h File Reference
`#include <stdbool.h>`
`#include <inttypes.h>`
`#include "ws_symbol_export.h"`

Go to the source code of this file.

## Functions
WS_DLL_PUBLIC bool | ws_strtoi64 (const char *str, const char **endptr, int64_t *cint)
| Convert a decimal string to a signed/unsigned int, with error checks.
WS_DLL_PUBLIC bool | ws_strtoi32 (const char *str, const char **endptr, int32_t *cint)
| Convert a string to an integer of specified size.
WS_DLL_PUBLIC bool | ws_strtoi16 (const char *str, const char **endptr, int16_t *cint)
| Convert a string to a 16-bit integer.
WS_DLL_PUBLIC bool | ws_strtoi8 (const char *str, const char **endptr, int8_t *cint)
| Convert a string to an 8-bit integer.
WS_DLL_PUBLIC bool | ws_strtoi (const char *str, const char **endptr, int *cint)
| Convert a string to an integer.
WS_DLL_PUBLIC bool | ws_strtou64 (const char *str, const char **endptr, uint64_t *cint)
| Convert a decimal string to a 64-bit unsigned int, with error checks.
WS_DLL_PUBLIC bool | ws_strtou32 (const char *str, const char **endptr, uint32_t *cint)
| Convert a decimal string to a 32-bit unsigned int, with error checks.
WS_DLL_PUBLIC bool | ws_strtou16 (const char *str, const char **endptr, uint16_t *cint)
| Convert a decimal string to an unsigned int, with error checks.
WS_DLL_PUBLIC bool | ws_strtou8 (const char *str, const char **endptr, uint8_t *cint)
| Convert a decimal string to an unsigned int, with error checks.
WS_DLL_PUBLIC bool | ws_strtou (const char *str, const char **endptr, unsigned *cint)
| Convert a decimal string to an unsigned int, with error checks.
WS_DLL_PUBLIC bool | ws_hexstrtou64 (const char *str, const char **endptr, uint64_t *cint)
| Convert a hexadecimal string to an unsigned int, with error checks.
WS_DLL_PUBLIC bool | ws_hexstrtou32 (const char *str, const char **endptr, uint32_t *cint)
| Convert a hexadecimal string to an 32-bit unsigned int, with error checks.
WS_DLL_PUBLIC bool | ws_hexstrtou16 (const char *str, const char **endptr, uint16_t *cint)
| Convert a hexadecimal string to an 16-bit unsigned int, with error checks.
WS_DLL_PUBLIC bool | ws_hexstrtou8 (const char *str, const char **endptr, uint8_t *cint)
| Convert a hexadecimal string in the specified base to an 8-bit unsigned int, with error checks.
WS_DLL_PUBLIC bool | ws_hexstrtou (const char *str, const char **endptr, unsigned *cint)
| Convert a hexadecimal string to an unsigned int, with error checks.
WS_DLL_PUBLIC bool | ws_basestrtou64 (const char *str, const char **endptr, uint64_t *cint, int base)
| Convert a string in the specified base to a 64-bit unsigned int, with error checks.
WS_DLL_PUBLIC bool | ws_basestrtou32 (const char *str, const char **endptr, uint32_t *cint, int base)
| Convert a string in the specified base to a 32-bit unsigned int, with error checks.
WS_DLL_PUBLIC bool | ws_basestrtou16 (const char *str, const char **endptr, uint16_t *cint, int base)
| Convert a string in the specified base to a 16-bit unsigned int, with error checks.
WS_DLL_PUBLIC bool | ws_basestrtou8 (const char *str, const char **endptr, uint8_t *cint, int base)
| Convert a string in the specified base to an 8-bit unsigned int, with error checks.
WS_DLL_PUBLIC bool | ws_basestrtou (const char *str, const char **endptr, unsigned *cint, int base)
| Convert a string in the specified base to an unsigned int, with error checks.
WS_DLL_PUBLIC bool | ws_basebuftou64 (const uint8_t *buf, size_t len, const uint8_t **endptr, uint64_t *cint, int base)
| Convert a counted string (not necessarily null terminated, of the given length) in the specified base to an unsigned 64-bit integer, with error checks.
WS_DLL_PUBLIC bool | ws_buftou64 (const uint8_t *buf, size_t len, const uint8_t **endptr, uint64_t *cint)
| Convert a counted decimal string (not necessarily null terminated, of the given length) to an unsigned 64-bit integer, with error checks.
WS_DLL_PUBLIC bool | ws_hexbuftou64 (const uint8_t *buf, size_t len, const uint8_t **endptr, uint64_t *cint)
| Convert a counted hexadecimal string (not necessarily null terminated, of the given length) to an unsigned 64-bit integer, with error checks.
WS_DLL_PUBLIC bool | ws_basebuftou32 (const uint8_t *buf, size_t len, const uint8_t **endptr, uint32_t *cint, int base)
| Parse a uint32_t from a byte buffer using a specified numeric base.
WS_DLL_PUBLIC bool | ws_buftou32 (const uint8_t *buf, size_t len, const uint8_t **endptr, uint32_t *cint)
| Parse a uint32_t from a byte buffer in base 10.
WS_DLL_PUBLIC bool | ws_hexbuftou32 (const uint8_t *buf, size_t len, const uint8_t **endptr, uint32_t *cint)
| Parse a uint32_t from a byte buffer in base 16 (hexadecimal).
WS_DLL_PUBLIC bool | ws_basebuftou16 (const uint8_t *buf, size_t len, const uint8_t **endptr, uint16_t *cint, int base)
| Parse a uint16_t from a byte buffer using a specified numeric base.
WS_DLL_PUBLIC bool | ws_buftou16 (const uint8_t *buf, size_t len, const uint8_t **endptr, uint16_t *cint)
| Parse a uint16_t from a byte buffer in base 10.
WS_DLL_PUBLIC bool | ws_hexbuftou16 (const uint8_t *buf, size_t len, const uint8_t **endptr, uint16_t *cint)
| Parse a uint16_t from a byte buffer in base 16 (hexadecimal).
WS_DLL_PUBLIC bool | ws_basebuftou8 (const uint8_t *buf, size_t len, const uint8_t **endptr, uint8_t *cint, int base)
| Parse a uint8_t from a byte buffer using a specified numeric base.
WS_DLL_PUBLIC bool | ws_buftou8 (const uint8_t *buf, size_t len, const uint8_t **endptr, uint8_t *cint)
| Parse a uint8_t from a byte buffer in base 10.
WS_DLL_PUBLIC bool | ws_hexbuftou8 (const uint8_t *buf, size_t len, const uint8_t **endptr, uint8_t *cint)
| Parse a uint8_t from a byte buffer in base 16 (hexadecimal).
WS_DLL_PUBLIC bool | ws_basebuftoi64 (const uint8_t *buf, size_t len, const uint8_t **endptr, int64_t *cint, int base)
| Convert a counted string (not necessarily null terminated, of the given length) in the specified base to a signed 64-bit integer, with error checks.
WS_DLL_PUBLIC bool | ws_buftoi64 (const uint8_t *buf, size_t len, const uint8_t **endptr, int64_t *cint)
| Convert a counted decimal string (not necessarily null terminated, of the given length) to a signed 64-bit integer, with error checks.
WS_DLL_PUBLIC bool | ws_hexbuftoi64 (const uint8_t *buf, size_t len, const uint8_t **endptr, int64_t *cint)
| Convert a counted hexadecimal string (not necessarily null terminated, of the given length) to a signed 64-bit integer, with error checks.
WS_DLL_PUBLIC bool | ws_basebuftoi32 (const uint8_t *buf, size_t len, const uint8_t **endptr, int32_t *cint, int base)
| Parse an int32_t from a byte buffer using a specified numeric base.
WS_DLL_PUBLIC bool | ws_buftoi32 (const uint8_t *buf, size_t len, const uint8_t **endptr, int32_t *cint)
| Parse an int32_t from a byte buffer in base 10.
WS_DLL_PUBLIC bool | ws_hexbuftoi32 (const uint8_t *buf, size_t len, const uint8_t **endptr, int32_t *cint)
| Parse an int32_t from a byte buffer in base 16 (hexadecimal).
WS_DLL_PUBLIC bool | ws_basebuftoi16 (const uint8_t *buf, size_t len, const uint8_t **endptr, int16_t *cint, int base)
| Parse an int16_t from a byte buffer using a specified numeric base.
WS_DLL_PUBLIC bool | ws_buftoi16 (const uint8_t *buf, size_t len, const uint8_t **endptr, int16_t *cint)
| Parse an int16_t from a byte buffer in base 10.
WS_DLL_PUBLIC bool | ws_hexbuftoi16 (const uint8_t *buf, size_t len, const uint8_t **endptr, int16_t *cint)
| Parse an int16_t from a byte buffer in base 16 (hexadecimal).
WS_DLL_PUBLIC bool | ws_basebuftoi8 (const uint8_t *buf, size_t len, const uint8_t **endptr, int8_t *cint, int base)
| Parse an int8_t from a byte buffer using a specified numeric base.
WS_DLL_PUBLIC bool | ws_buftoi8 (const uint8_t *buf, size_t len, const uint8_t **endptr, int8_t *cint)
| Parse an int8_t from a byte buffer in base 10.
WS_DLL_PUBLIC bool | ws_hexbuftoi8 (const uint8_t *buf, size_t len, const uint8_t **endptr, int8_t *cint)
| Parse an int8_t from a byte buffer in base 16 (hexadecimal).

## Detailed Description

Utilities to convert strings to integers

Copyright 2016, Dario Lombardo

Wireshark - Network traffic analyzer By Gerald Combs geral.nosp@m.d@wi.nosp@m.resha.nosp@m.rk.o.nosp@m.rg Copyright 1998 Gerald Combs

SPDX-License-Identifier: GPL-2.0-or-later

## Function Documentation

## ◆ ws_basebuftoi16()

WS_DLL_PUBLIC bool ws_basebuftoi16 | ( | const uint8_t * | buf,
|  | size_t | len,
|  | const uint8_t ** | endptr,
|  | int16_t * | cint,
|  | int | base )

Parse an int16_t from a byte buffer using a specified numeric base.

Parameters

  buf | Pointer to the input byte buffer.
  len | Number of bytes available in `buf`.
  endptr | Set to one past the last byte consumed; NULL to ignore.
  cint | Receives the parsed int16_t value on success.
  base | Numeric base to use for parsing (e.g. 10, 16).

Returns
  true on success, false on parse error or overflow.

## ◆ ws_basebuftoi32()

WS_DLL_PUBLIC bool ws_basebuftoi32 | ( | const uint8_t * | buf,
|  | size_t | len,
|  | const uint8_t ** | endptr,
|  | int32_t * | cint,
|  | int | base )

Parse an int32_t from a byte buffer using a specified numeric base.

Parameters

  buf | Pointer to the input byte buffer.
  len | Number of bytes available in `buf`.
  endptr | Set to one past the last byte consumed; NULL to ignore.
  cint | Receives the parsed int32_t value on success.
  base | Numeric base to use for parsing (e.g. 10, 16).

Returns
  true on success, false if no valid digits were found, the buffer was exhausted, or the value overflows int32_t.

## ◆ ws_basebuftoi64()

WS_DLL_PUBLIC bool ws_basebuftoi64 | ( | const uint8_t * | buf,
|  | size_t | len,
|  | const uint8_t ** | endptr,
|  | int64_t * | cint,
|  | int | base )

Convert a counted string (not necessarily null terminated, of the given length) in the specified base to a signed 64-bit integer, with error checks.

Parameters

  buf | The string buffer to convert
  len | The length of the string
  endptr | A pointer that will store a pointer to the first invalid character in str, allowing a number to be parsed even if there is trailing whitespace. If NULL, then the string is assumed to contain only valid characters (or it will error out).
  cint | The converted integer
  base | The base for the integer; 0 means "if it begins with 0x, it's hex, otherwise if it begins with 0, it's octal, otherwise it's decimal".

Returns
  true if the conversion succeeds, false otherwise. On error, errno is set to EINVAL for unrecognized input and ERANGE if the resulting number does not fit in the type.

Note
  This is useful when a string representation of an integer is not null-terminated and also cannot be modified to insert a NULL (e.g., a const uint8_t* from packet data), avoiding having to copy the string. This allows a sign, either '+' or '-', to prefix the string.

## ◆ ws_basebuftoi8()

WS_DLL_PUBLIC bool ws_basebuftoi8 | ( | const uint8_t * | buf,
|  | size_t | len,
|  | const uint8_t ** | endptr,
|  | int8_t * | cint,
|  | int | base )

Parse an int8_t from a byte buffer using a specified numeric base.

Parameters

  buf | Pointer to the input byte buffer.
  len | Number of bytes available in `buf`.
  endptr | Set to one past the last byte consumed; NULL to ignore.
  cint | Receives the parsed int8_t value on success.
  base | Numeric base to use for parsing (e.g. 10, 16).

Returns
  true on success, false on parse error or overflow.

## ◆ ws_basebuftou16()

WS_DLL_PUBLIC bool ws_basebuftou16 | ( | const uint8_t * | buf,
|  | size_t | len,
|  | const uint8_t ** | endptr,
|  | uint16_t * | cint,
|  | int | base )

Parse a uint16_t from a byte buffer using a specified numeric base.

Parameters

  buf | Pointer to the input byte buffer.
  len | Number of bytes available in `buf`.
  endptr | Set to one past the last byte consumed; NULL to ignore.
  cint | Receives the parsed uint16_t value on success.
  base | Numeric base to use for parsing (e.g. 10, 16).

Returns
  true on success, false on parse error or overflow.

## ◆ ws_basebuftou32()

WS_DLL_PUBLIC bool ws_basebuftou32 | ( | const uint8_t * | buf,
|  | size_t | len,
|  | const uint8_t ** | endptr,
|  | uint32_t * | cint,
|  | int | base )

Parse a uint32_t from a byte buffer using a specified numeric base.

Reads up to `len` bytes from `buf`, interpreting them as an unsigned integer in the given `base`. On success, stores the result in `cint` and sets `endptr` to one past the last consumed byte.

Parameters

  buf | Pointer to the input byte buffer.
  len | Number of bytes available in `buf`.
  endptr | Set to one past the last byte consumed; NULL to ignore.
  cint | Receives the parsed uint32_t value on success.
  base | Numeric base to use for parsing (e.g. 10, 16).

Returns
  true on success, false if no valid digits were found, the buffer was exhausted, or the value overflows uint32_t.

## ◆ ws_basebuftou64()

WS_DLL_PUBLIC bool ws_basebuftou64 | ( | const uint8_t * | buf,
|  | size_t | len,
|  | const uint8_t ** | endptr,
|  | uint64_t * | cint,
|  | int | base )

Convert a counted string (not necessarily null terminated, of the given length) in the specified base to an unsigned 64-bit integer, with error checks.

Parameters

  buf | The string buffer to convert
  len | The length of the string
  endptr | A pointer that will store a pointer to the first invalid character in str, allowing a number to be parsed even if there is trailing whitespace. If NULL, then the string is assumed to contain only valid characters (or it will error out).
  cint | The converted integer
  base | The base for the integer; 0 means "if it begins with 0x, it's hex, otherwise if it begins with 0, it's octal, otherwise it's decimal".

Returns
  true if the conversion succeeds, false otherwise. On error, errno is set to EINVAL for unrecognized input and ERANGE if the resulting number does not fit in the type.

Note
  This is useful when a string representation of an integer is not null-terminated and also cannot be modified to insert a NULL (e.g., a const uint8_t* from packet data), avoiding having to copy the string. This does not allow a sign, neither '+' nor '-', prefixing the string, unlike strtoull and g_ascii_strtoull. (The latter allow a negative sign and cast to unsigned in the normal way.)

## ◆ ws_basebuftou8()

WS_DLL_PUBLIC bool ws_basebuftou8 | ( | const uint8_t * | buf,
|  | size_t | len,
|  | const uint8_t ** | endptr,
|  | uint8_t * | cint,
|  | int | base )

Parse a uint8_t from a byte buffer using a specified numeric base.

Parameters

  buf | Pointer to the input byte buffer.
  len | Number of bytes available in `buf`.
  endptr | Set to one past the last byte consumed; NULL to ignore.
  cint | Receives the parsed uint8_t value on success.
  base | Numeric base to use for parsing (e.g. 10, 16).

Returns
  true on success, false on parse error or overflow.

## ◆ ws_basestrtou()

WS_DLL_PUBLIC bool ws_basestrtou | ( | const char * | str,
|  | const char ** | endptr,
|  | unsigned * | cint,
|  | int | base )

Convert a string in the specified base to an unsigned int, with error checks.

Parameters

  str | The string to convert
  endptr | A pointer that will store a pointer to the first invalid character in str, allowing a number to be parsed even if there is trailing whitespace. If NULL, then the string is assumed to contain only valid characters (or it will error out).
  cint | The converted integer
  base | The base for the integer; 0 means "if it begins with 0x, it's hex, otherwise if it begins with 0, it's octal, otherwise it's decimal".

Returns
  true if the conversion succeeds, false otherwise. On error, errno is set to EINVAL for unrecognized input and ERANGE if the resulting number does not fit in the type.

## ◆ ws_basestrtou16()

WS_DLL_PUBLIC bool ws_basestrtou16 | ( | const char * | str,
|  | const char ** | endptr,
|  | uint16_t * | cint,
|  | int | base )

Convert a string in the specified base to a 16-bit unsigned int, with error checks.

Parameters

  str | The string to convert
  endptr | A pointer that will store a pointer to the first invalid character in str, allowing a number to be parsed even if there is trailing whitespace. If NULL, then the string is assumed to contain only valid characters (or it will error out).
  cint | The converted integer
  base | The base for the integer; 0 means "if it begins with 0x, it's hex, otherwise if it begins with 0, it's octal, otherwise it's decimal".

Returns
  true if the conversion succeeds, false otherwise. On error, errno is set to EINVAL for unrecognized input and ERANGE if the resulting number does not fit in the type.

## ◆ ws_basestrtou32()

WS_DLL_PUBLIC bool ws_basestrtou32 | ( | const char * | str,
|  | const char ** | endptr,
|  | uint32_t * | cint,
|  | int | base )

Convert a string in the specified base to a 32-bit unsigned int, with error checks.

Parameters

  str | The string to convert
  endptr | A pointer that will store a pointer to the first invalid character in str, allowing a number to be parsed even if there is trailing whitespace. If NULL, then the string is assumed to contain only valid characters (or it will error out).
  cint | The converted integer
  base | The base for the integer; 0 means "if it begins with 0x, it's hex, otherwise if it begins with 0, it's octal, otherwise it's decimal".

Returns
  true if the conversion succeeds, false otherwise. On error, errno is set to EINVAL for unrecognized input and ERANGE if the resulting number does not fit in the type.

## ◆ ws_basestrtou64()

WS_DLL_PUBLIC bool ws_basestrtou64 | ( | const char * | str,
|  | const char ** | endptr,
|  | uint64_t * | cint,
|  | int | base )

Convert a string in the specified base to a 64-bit unsigned int, with error checks.

Parameters

  str | The string to convert
  endptr | A pointer that will store a pointer to the first invalid character in str, allowing a number to be parsed even if there is trailing whitespace. If NULL, then the string is assumed to contain only valid characters (or it will error out).
  cint | The converted integer
  base | The base for the integer; 0 means "if it begins with 0x, it's hex, otherwise if it begins with 0, it's octal, otherwise it's decimal".

Returns
  true if the conversion succeeds, false otherwise. On error, errno is set to EINVAL for unrecognized input and ERANGE if the resulting number does not fit in the type.

## ◆ ws_basestrtou8()

WS_DLL_PUBLIC bool ws_basestrtou8 | ( | const char * | str,
|  | const char ** | endptr,
|  | uint8_t * | cint,
|  | int | base )

Convert a string in the specified base to an 8-bit unsigned int, with error checks.

Parameters

  str | The string to convert
  endptr | A pointer that will store a pointer to the first invalid character in str, allowing a number to be parsed even if there is trailing whitespace. If NULL, then the string is assumed to contain only valid characters (or it will error out).
  cint | The converted integer
  base | The base for the integer; 0 means "if it begins with 0x, it's hex, otherwise if it begins with 0, it's octal, otherwise it's decimal".

Returns
  true if the conversion succeeds, false otherwise. On error, errno is set to EINVAL for unrecognized input and ERANGE if the resulting number does not fit in the type.

## ◆ ws_buftoi16()

WS_DLL_PUBLIC bool ws_buftoi16 | ( | const uint8_t * | buf,
|  | size_t | len,
|  | const uint8_t ** | endptr,
|  | int16_t * | cint )

Parse an int16_t from a byte buffer in base 10.

Parameters

  buf | Pointer to the input byte buffer.
  len | Number of bytes available in `buf`.
  endptr | Set to one past the last byte consumed; NULL to ignore.
  cint | Receives the parsed int16_t value on success.

Returns
  true on success, false on parse error or overflow.

## ◆ ws_buftoi32()

WS_DLL_PUBLIC bool ws_buftoi32 | ( | const uint8_t * | buf,
|  | size_t | len,
|  | const uint8_t ** | endptr,
|  | int32_t * | cint )

Parse an int32_t from a byte buffer in base 10.

Parameters

  buf | Pointer to the input byte buffer.
  len | Number of bytes available in `buf`.
  endptr | Set to one past the last byte consumed; NULL to ignore.
  cint | Receives the parsed int32_t value on success.

Returns
  true on success, false on parse error or overflow.

## ◆ ws_buftoi64()

WS_DLL_PUBLIC bool ws_buftoi64 | ( | const uint8_t * | buf,
|  | size_t | len,
|  | const uint8_t ** | endptr,
|  | int64_t * | cint )

Convert a counted decimal string (not necessarily null terminated, of the given length) to a signed 64-bit integer, with error checks.

Parameters

  buf | The string buffer to convert
  len | The length of the string
  endptr | A pointer that will store a pointer to the first invalid character in str, allowing a number to be parsed even if there is trailing whitespace. If NULL, then the string is assumed to contain only valid characters (or it will error out).
  cint | The converted integer

Returns
  true if the conversion succeeds, false otherwise. On error, errno is set to EINVAL for unrecognized input and ERANGE if the resulting number does not fit in the type.

Note
  This is useful when a string representation of an integer is not null-terminated and also cannot be modified to insert a NULL (e.g., a const uint8_t* from packet data), avoiding having to copy the string. This allows a sign, either '+' or '-', to prefix the string.

## ◆ ws_buftoi8()

WS_DLL_PUBLIC bool ws_buftoi8 | ( | const uint8_t * | buf,
|  | size_t | len,
|  | const uint8_t ** | endptr,
|  | int8_t * | cint )

Parse an int8_t from a byte buffer in base 10.

Parameters

  buf | Pointer to the input byte buffer.
  len | Number of bytes available in `buf`.
  endptr | Set to one past the last byte consumed; NULL to ignore.
  cint | Receives the parsed int8_t value on success.

Returns
  true on success, false on parse error or overflow.

## ◆ ws_buftou16()

WS_DLL_PUBLIC bool ws_buftou16 | ( | const uint8_t * | buf,
|  | size_t | len,
|  | const uint8_t ** | endptr,
|  | uint16_t * | cint )

Parse a uint16_t from a byte buffer in base 10.

Convenience wrapper around ws_basebuftou16() using base 10.

Parameters

  buf | Pointer to the input byte buffer.
  len | Number of bytes available in `buf`.
  endptr | Set to one past the last byte consumed; NULL to ignore.
  cint | Receives the parsed uint16_t value on success.

Returns
  true on success, false on parse error or overflow.

## ◆ ws_buftou32()

WS_DLL_PUBLIC bool ws_buftou32 | ( | const uint8_t * | buf,
|  | size_t | len,
|  | const uint8_t ** | endptr,
|  | uint32_t * | cint )

Parse a uint32_t from a byte buffer in base 10.

Convenience wrapper around ws_basebuftou32() using base 10.

Parameters

  buf | Pointer to the input byte buffer.
  len | Number of bytes available in `buf`.
  endptr | Set to one past the last byte consumed; NULL to ignore.
  cint | Receives the parsed uint32_t value on success.

Returns
  true on success, false on parse error or overflow.

## ◆ ws_buftou64()

WS_DLL_PUBLIC bool ws_buftou64 | ( | const uint8_t * | buf,
|  | size_t | len,
|  | const uint8_t ** | endptr,
|  | uint64_t * | cint )

Convert a counted decimal string (not necessarily null terminated, of the given length) to an unsigned 64-bit integer, with error checks.

Parameters

  buf | The string buffer to convert
  len | The length of the string
  endptr | A pointer that will store a pointer to the first invalid character in str, allowing a number to be parsed even if there is trailing whitespace. If NULL, then the string is assumed to contain only valid characters (or it will error out).
  cint | The converted integer

Returns
  true if the conversion succeeds, false otherwise. On error, errno is set to EINVAL for unrecognized input and ERANGE if the resulting number does not fit in the type.

Note
  This does not allow a sign, neither '+' nor '-', prefixing the string, unlike strtoull and g_ascii_strtoull. (The latter allow a negative sign and cast to unsigned in the normal way.)

## ◆ ws_buftou8()

WS_DLL_PUBLIC bool ws_buftou8 | ( | const uint8_t * | buf,
|  | size_t | len,
|  | const uint8_t ** | endptr,
|  | uint8_t * | cint )

Parse a uint8_t from a byte buffer in base 10.

Convenience wrapper around ws_basebuftou8() using base 10.

Parameters

  buf | Pointer to the input byte buffer.
  len | Number of bytes available in `buf`.
  endptr | Set to one past the last byte consumed; NULL to ignore.
  cint | Receives the parsed uint8_t value on success.

Returns
  true on success, false on parse error or overflow.

## ◆ ws_hexbuftoi16()

WS_DLL_PUBLIC bool ws_hexbuftoi16 | ( | const uint8_t * | buf,
|  | size_t | len,
|  | const uint8_t ** | endptr,
|  | int16_t * | cint )

Parse an int16_t from a byte buffer in base 16 (hexadecimal).

Parameters

  buf | Pointer to the input byte buffer.
  len | Number of bytes available in `buf`.
  endptr | Set to one past the last byte consumed; NULL to ignore.
  cint | Receives the parsed int16_t value on success.

Returns
  true on success, false on parse error or overflow.

## ◆ ws_hexbuftoi32()

WS_DLL_PUBLIC bool ws_hexbuftoi32 | ( | const uint8_t * | buf,
|  | size_t | len,
|  | const uint8_t ** | endptr,
|  | int32_t * | cint )

Parse an int32_t from a byte buffer in base 16 (hexadecimal).

Parameters

  buf | Pointer to the input byte buffer.
  len | Number of bytes available in `buf`.
  endptr | Set to one past the last byte consumed; NULL to ignore.
  cint | Receives the parsed int32_t value on success.

Returns
  true on success, false on parse error or overflow.

## ◆ ws_hexbuftoi64()

WS_DLL_PUBLIC bool ws_hexbuftoi64 | ( | const uint8_t * | buf,
|  | size_t | len,
|  | const uint8_t ** | endptr,
|  | int64_t * | cint )

Convert a counted hexadecimal string (not necessarily null terminated, of the given length) to a signed 64-bit integer, with error checks.

Parameters

  buf | The string buffer to convert
  len | The length of the string
  endptr | A pointer that will store a pointer to the first invalid character in str, allowing a number to be parsed even if there is trailing whitespace. If NULL, then the string is assumed to contain only valid characters (or it will error out).
  cint | The converted integer

Returns
  true if the conversion succeeds, false otherwise. On error, errno is set to EINVAL for unrecognized input and ERANGE if the resulting number does not fit in the type.

Note
  This is useful when a string representation of an integer is not null-terminated and also cannot be modified to insert a NULL (e.g., a const uint8_t* from packet data), avoiding having to copy the string. This allows a sign, either '+' or '-', to prefix the string.

## ◆ ws_hexbuftoi8()

WS_DLL_PUBLIC bool ws_hexbuftoi8 | ( | const uint8_t * | buf,
|  | size_t | len,
|  | const uint8_t ** | endptr,
|  | int8_t * | cint )

Parse an int8_t from a byte buffer in base 16 (hexadecimal).

Parameters

  buf | Pointer to the input byte buffer.
  len | Number of bytes available in `buf`.
  endptr | Set to one past the last byte consumed; NULL to ignore.
  cint | Receives the parsed int8_t value on success.

Returns
  true on success, false on parse error or overflow.

## ◆ ws_hexbuftou16()

WS_DLL_PUBLIC bool ws_hexbuftou16 | ( | const uint8_t * | buf,
|  | size_t | len,
|  | const uint8_t ** | endptr,
|  | uint16_t * | cint )

Parse a uint16_t from a byte buffer in base 16 (hexadecimal).

Convenience wrapper around ws_basebuftou16() using base 16.

Parameters

  buf | Pointer to the input byte buffer.
  len | Number of bytes available in `buf`.
  endptr | Set to one past the last byte consumed; NULL to ignore.
  cint | Receives the parsed uint16_t value on success.

Returns
  true on success, false on parse error or overflow.

## ◆ ws_hexbuftou32()

WS_DLL_PUBLIC bool ws_hexbuftou32 | ( | const uint8_t * | buf,
|  | size_t | len,
|  | const uint8_t ** | endptr,
|  | uint32_t * | cint )

Parse a uint32_t from a byte buffer in base 16 (hexadecimal).

Convenience wrapper around ws_basebuftou32() using base 16.

Parameters

  buf | Pointer to the input byte buffer.
  len | Number of bytes available in `buf`.
  endptr | Set to one past the last byte consumed; NULL to ignore.
  cint | Receives the parsed uint32_t value on success.

Returns
  true on success, false on parse error or overflow.

## ◆ ws_hexbuftou64()

WS_DLL_PUBLIC bool ws_hexbuftou64 | ( | const uint8_t * | buf,
|  | size_t | len,
|  | const uint8_t ** | endptr,
|  | uint64_t * | cint )

Convert a counted hexadecimal string (not necessarily null terminated, of the given length) to an unsigned 64-bit integer, with error checks.

Parameters

  buf | The string buffer to convert
  len | The length of the string
  endptr | A pointer that will store a pointer to the first invalid character in str, allowing a number to be parsed even if there is trailing whitespace. If NULL, then the string is assumed to contain only valid characters (or it will error out).
  cint | The converted integer

Returns
  true if the conversion succeeds, false otherwise. On error, errno is set to EINVAL for unrecognized input and ERANGE if the resulting number does not fit in the type.

Note
  This does not allow a sign, neither '+' nor '-', prefixing the string, unlike strtoull and g_ascii_strtoull. (The latter allow a negative sign and cast to unsigned in the normal way.)

## ◆ ws_hexbuftou8()

WS_DLL_PUBLIC bool ws_hexbuftou8 | ( | const uint8_t * | buf,
|  | size_t | len,
|  | const uint8_t ** | endptr,
|  | uint8_t * | cint )

Parse a uint8_t from a byte buffer in base 16 (hexadecimal).

Convenience wrapper around ws_basebuftou8() using base 16.

Parameters

  buf | Pointer to the input byte buffer.
  len | Number of bytes available in `buf`.
  endptr | Set to one past the last byte consumed; NULL to ignore.
  cint | Receives the parsed uint8_t value on success.

Returns
  true on success, false on parse error or overflow.

## ◆ ws_hexstrtou()

WS_DLL_PUBLIC bool ws_hexstrtou | ( | const char * | str,
|  | const char ** | endptr,
|  | unsigned * | cint )

Convert a hexadecimal string to an unsigned int, with error checks.

Parameters

  str | The hexadecimal string to convert.
  endptr | A pointer that will store a pointer to the first invalid character in str, allowing a number to be parsed even if there is trailing whitespace. If NULL, then the string is assumed to contain only valid characters.

Returns
  true if the conversion was successful, false otherwise.

## ◆ ws_hexstrtou16()

WS_DLL_PUBLIC bool ws_hexstrtou16 | ( | const char * | str,
|  | const char ** | endptr,
|  | uint16_t * | cint )

Convert a hexadecimal string to an 16-bit unsigned int, with error checks.

Parameters

  str | The hexadecimal string to convert.
  endptr | A pointer that will store a pointer to the first invalid character encountered during conversion.

Returns
  true If the conversion was successful.
  false If the conversion failed.

## ◆ ws_hexstrtou32()

WS_DLL_PUBLIC bool ws_hexstrtou32 | ( | const char * | str,
|  | const char ** | endptr,
|  | uint32_t * | cint )

Convert a hexadecimal string to an 32-bit unsigned int, with error checks.

Parameters

  str | The hexadecimal string to convert.
  endptr | A pointer that will store a pointer to the first invalid character encountered during conversion.

Returns
  true If the conversion was successful.
  false If the conversion failed.

## ◆ ws_hexstrtou64()

WS_DLL_PUBLIC bool ws_hexstrtou64 | ( | const char * | str,
|  | const char ** | endptr,
|  | uint64_t * | cint )

Convert a hexadecimal string to an unsigned int, with error checks.

Parameters

  str | The hexadecimal string to convert
  endptr | A pointer that will store a pointer to the first invalid character in str, allowing a number to be parsed even if there is trailing whitespace. If NULL, then the string is assumed to contain only valid characters (or it will error out).
  cint | The converted integer

Returns
  true if the conversion succeeds, false otherwise. On error, errno is set to EINVAL for unrecognized input and ERANGE if the resulting number does not fit in the type.

## ◆ ws_hexstrtou8()

WS_DLL_PUBLIC bool ws_hexstrtou8 | ( | const char * | str,
|  | const char ** | endptr,
|  | uint8_t * | cint )

Convert a hexadecimal string in the specified base to an 8-bit unsigned int, with error checks.

Parameters

  str | The hexadecimal string to convert.
  endptr | A pointer that will store a pointer to the first invalid character encountered during conversion.

Returns
  true If the conversion was successful.
  false If the conversion failed.

## ◆ ws_strtoi()

WS_DLL_PUBLIC bool ws_strtoi | ( | const char * | str,
|  | const char ** | endptr,
|  | int * | cint )

Convert a string to an integer.

Converts the initial part of the string pointed to by 'str' to an int.

Parameters

  str | The string to be converted.
  endptr | A pointer to a char pointer that will receive the address of the first character not converted.
  cint | A pointer to an int where the result will be stored.

Returns
  true if successful, false otherwise.

## ◆ ws_strtoi16()

WS_DLL_PUBLIC bool ws_strtoi16 | ( | const char * | str,
|  | const char ** | endptr,
|  | int16_t * | cint )

Convert a string to a 16-bit integer.

Converts the initial portion of the string pointed to by str to an int value.

Parameters

  str | The string to be converted.
  endptr | A pointer to a char pointer that will receive the address of the first character not part of the conversion.
  cint | Pointer to the location where the result should be stored.

Returns
  true if successful, false otherwise.

## ◆ ws_strtoi32()

WS_DLL_PUBLIC bool ws_strtoi32 | ( | const char * | str,
|  | const char ** | endptr,
|  | int32_t * | cint )

Convert a string to an integer of specified size.

Converts a string to an integer of the specified size and stores the result in the provided variable.

Parameters

  str | The input string to convert.
  endptr | A pointer to a character that will be set to point to the first character after the converted number.
  cint | A pointer to the variable where the converted integer will be stored.

Returns
  true if the conversion was successful, false otherwise.

## ◆ ws_strtoi64()

WS_DLL_PUBLIC bool ws_strtoi64 | ( | const char * | str,
|  | const char ** | endptr,
|  | int64_t * | cint )

Convert a decimal string to a signed/unsigned int, with error checks.

Parameters

  str | The string to convert
  endptr | A pointer that will store a pointer to the first invalid character in str, allowing a number to be parsed even if there is trailing whitespace. If NULL, then the string is assumed to contain only valid characters (or it will error out).
  cint | The converted integer

Returns
  true if the conversion succeeds, false otherwise. On error, errno is set to EINVAL for unrecognized input and ERANGE if the resulting number does not fit in the type.

## ◆ ws_strtoi8()

WS_DLL_PUBLIC bool ws_strtoi8 | ( | const char * | str,
|  | const char ** | endptr,
|  | int8_t * | cint )

Convert a string to an 8-bit integer.

Converts the initial portion of the string pointed to by str to an int value.

Parameters

  str | The string to be converted.
  endptr | A pointer to a char pointer that will receive the address of the first character not part of the conversion.
  cint | Pointer to the location where the result should be stored.

Returns
  true if successful, false otherwise.

## ◆ ws_strtou()

WS_DLL_PUBLIC bool ws_strtou | ( | const char * | str,
|  | const char ** | endptr,
|  | unsigned * | cint )

Convert a decimal string to an unsigned int, with error checks.

Parameters

  str | The string to convert
  endptr | A pointer that will store a pointer to the first invalid character in str, allowing a number to be parsed even if there is trailing whitespace. If NULL, then the string is assumed to contain only valid characters (or it will error out).

Returns
  true on success, false on failure.

## ◆ ws_strtou16()

WS_DLL_PUBLIC bool ws_strtou16 | ( | const char * | str,
|  | const char ** | endptr,
|  | uint16_t * | cint )

Convert a decimal string to an unsigned int, with error checks.

Parameters

  str | The string to convert
  endptr | A pointer to a char pointer that will receive the address of the first character not converted.

Returns
  true if the conversion was successful, false otherwise.

## ◆ ws_strtou32()

WS_DLL_PUBLIC bool ws_strtou32 | ( | const char * | str,
|  | const char ** | endptr,
|  | uint32_t * | cint )

Convert a decimal string to a 32-bit unsigned int, with error checks.

Parameters

  str | The string to convert
  endptr | A pointer to a char pointer that will receive the address of the first character not converted.
  cint | A pointer to a uint32_t where the result will be stored.

Returns
  true if conversion is successful, false otherwise

## ◆ ws_strtou64()

WS_DLL_PUBLIC bool ws_strtou64 | ( | const char * | str,
|  | const char ** | endptr,
|  | uint64_t * | cint )

Convert a decimal string to a 64-bit unsigned int, with error checks.

Parameters

  str | The string to convert
  endptr | A pointer to a char pointer that will receive the address of the first character not converted.
  cint | A pointer to a uint64_t where the result will be stored.

Returns
  true if conversion is successful, false otherwise

## ◆ ws_strtou8()

WS_DLL_PUBLIC bool ws_strtou8 | ( | const char * | str,
|  | const char ** | endptr,
|  | uint8_t * | cint )

Convert a decimal string to an unsigned int, with error checks.

Parameters

  str | The string to convert
  endptr | A pointer that will store a pointer to the first invalid character in str, allowing a number to be parsed even if there is trailing whitespace. If NULL, then the string is assumed to contain only valid characters.

Returns
  true on success, false otherwise