Line data    Source code

       1             : /* SPDX-License-Identifier: LGPL-2.1+ */
       2             : #pragma once
       3             : 
       4             : #include <inttypes.h>
       5             : #include <limits.h>
       6             : #include <stddef.h>
       7             : #include <stdint.h>
       8             : #include <sys/types.h>
       9             : 
      10             : #include "macro.h"
      11             : 
      12             : int parse_boolean(const char *v) _pure_;
      13             : int parse_dev(const char *s, dev_t *ret);
      14             : int parse_pid(const char *s, pid_t* ret_pid);
      15             : int parse_mode(const char *s, mode_t *ret);
      16             : int parse_ifindex(const char *s, int *ret);
      17             : int parse_ifindex_or_ifname(const char *s, int *ret);
      18             : int parse_mtu(int family, const char *s, uint32_t *ret);
      19             : 
      20             : int parse_size(const char *t, uint64_t base, uint64_t *size);
      21             : int parse_range(const char *t, unsigned *lower, unsigned *upper);
      22             : int parse_errno(const char *t);
      23             : int parse_syscall_and_errno(const char *in, char **name, int *error);
      24             : 
      25             : int safe_atou_full(const char *s, unsigned base, unsigned *ret_u);
      26             : 
      27      104890 : static inline int safe_atou(const char *s, unsigned *ret_u) {
      28      104890 :         return safe_atou_full(s, 0, ret_u);
      29             : }
      30             : 
      31             : int safe_atoi(const char *s, int *ret_i);
      32             : int safe_atollu(const char *s, unsigned long long *ret_u);
      33             : int safe_atolli(const char *s, long long int *ret_i);
      34             : 
      35             : int safe_atou8(const char *s, uint8_t *ret);
      36             : 
      37             : int safe_atou16_full(const char *s, unsigned base, uint16_t *ret);
      38             : 
      39          42 : static inline int safe_atou16(const char *s, uint16_t *ret) {
      40          42 :         return safe_atou16_full(s, 0, ret);
      41             : }
      42             : 
      43          10 : static inline int safe_atoux16(const char *s, uint16_t *ret) {
      44          10 :         return safe_atou16_full(s, 16, ret);
      45             : }
      46             : 
      47             : int safe_atoi16(const char *s, int16_t *ret);
      48             : 
      49         264 : static inline int safe_atou32(const char *s, uint32_t *ret_u) {
      50             :         assert_cc(sizeof(uint32_t) == sizeof(unsigned));
      51         264 :         return safe_atou(s, (unsigned*) ret_u);
      52             : }
      53             : 
      54           0 : static inline int safe_atoi32(const char *s, int32_t *ret_i) {
      55             :         assert_cc(sizeof(int32_t) == sizeof(int));
      56           0 :         return safe_atoi(s, (int*) ret_i);
      57             : }
      58             : 
      59        2609 : static inline int safe_atou64(const char *s, uint64_t *ret_u) {
      60             :         assert_cc(sizeof(uint64_t) == sizeof(unsigned long long));
      61        2609 :         return safe_atollu(s, (unsigned long long*) ret_u);
      62             : }
      63             : 
      64          10 : static inline int safe_atoi64(const char *s, int64_t *ret_i) {
      65             :         assert_cc(sizeof(int64_t) == sizeof(long long int));
      66          10 :         return safe_atolli(s, (long long int*) ret_i);
      67             : }
      68             : 
      69             : #if LONG_MAX == INT_MAX
      70             : static inline int safe_atolu(const char *s, unsigned long *ret_u) {
      71             :         assert_cc(sizeof(unsigned long) == sizeof(unsigned));
      72             :         return safe_atou(s, (unsigned*) ret_u);
      73             : }
      74             : static inline int safe_atoli(const char *s, long int *ret_u) {
      75             :         assert_cc(sizeof(long int) == sizeof(int));
      76             :         return safe_atoi(s, (int*) ret_u);
      77             : }
      78             : #else
      79         293 : static inline int safe_atolu(const char *s, unsigned long *ret_u) {
      80             :         assert_cc(sizeof(unsigned long) == sizeof(unsigned long long));
      81         293 :         return safe_atollu(s, (unsigned long long*) ret_u);
      82             : }
      83           0 : static inline int safe_atoli(const char *s, long int *ret_u) {
      84             :         assert_cc(sizeof(long int) == sizeof(long long int));
      85           0 :         return safe_atolli(s, (long long int*) ret_u);
      86             : }
      87             : #endif
      88             : 
      89             : #if SIZE_MAX == UINT_MAX
      90             : static inline int safe_atozu(const char *s, size_t *ret_u) {
      91             :         assert_cc(sizeof(size_t) == sizeof(unsigned));
      92             :         return safe_atou(s, (unsigned *) ret_u);
      93             : }
      94             : #else
      95           0 : static inline int safe_atozu(const char *s, size_t *ret_u) {
      96             :         assert_cc(sizeof(size_t) == sizeof(long unsigned));
      97           0 :         return safe_atolu(s, ret_u);
      98             : }
      99             : #endif
     100             : 
     101             : int safe_atod(const char *s, double *ret_d);
     102             : 
     103             : int parse_fractional_part_u(const char **s, size_t digits, unsigned *res);
     104             : 
     105             : int parse_percent_unbounded(const char *p);
     106             : int parse_percent(const char *p);
     107             : 
     108             : int parse_permille_unbounded(const char *p);
     109             : int parse_permille(const char *p);
     110             : 
     111             : int parse_nice(const char *p, int *ret);
     112             : 
     113             : int parse_ip_port(const char *s, uint16_t *ret);
     114             : int parse_ip_port_range(const char *s, uint16_t *low, uint16_t *high);
     115             : 
     116             : int parse_oom_score_adjust(const char *s, int *ret);