src/basic/parse-util.h

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 #pragma once
   3
   4 /***
   5   This file is part of systemd.
   6
   7   Copyright 2010 Lennart Poettering
   8
   9   systemd is free software; you can redistribute it and/or modify it
  10   under the terms of the GNU Lesser General Public License as published by
  11   the Free Software Foundation; either version 2.1 of the License, or
  12   (at your option) any later version.
  13
  14   systemd is distributed in the hope that it will be useful, but
  15   WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17   Lesser General Public License for more details.
  18
  19   You should have received a copy of the GNU Lesser General Public License
  20   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  21 ***/
  22
  23 #include <inttypes.h>
  24 #include <limits.h>
  25 #include <stddef.h>
  26 #include <stdint.h>
  27 #include <sys/types.h>
  28
  29 #include "macro.h"
  30
  31 #define MODE_INVALID ((mode_t) -1)
  32
  33 int parse_boolean(const char *v) _pure_;
  34 int parse_dev(const char *s, dev_t *ret);
  35 int parse_pid(const char *s, pid_t* ret_pid);
  36 int parse_mode(const char *s, mode_t *ret);
  37 int parse_ifindex(const char *s, int *ret);
  38
  39 int parse_size(const char *t, uint64_t base, uint64_t *size);
  40 int parse_range(const char *t, unsigned *lower, unsigned *upper);
  41 int parse_errno(const char *t);
  42 int parse_syscall_and_errno(const char *in, char **name, int *error);
  43
  44 #define FORMAT_BYTES_MAX 8
  45 char *format_bytes(char *buf, size_t l, uint64_t t);
  46
  47 int safe_atou_full(const char *s, unsigned base, unsigned *ret_u);
  48
  49 static inline int safe_atou(const char *s, unsigned *ret_u) {
  50         return safe_atou_full(s, 0, ret_u);
  51 }
  52
  53 int safe_atoi(const char *s, int *ret_i);
  54 int safe_atollu(const char *s, unsigned long long *ret_u);
  55 int safe_atolli(const char *s, long long int *ret_i);
  56
  57 int safe_atou8(const char *s, uint8_t *ret);
  58
  59 int safe_atou16_full(const char *s, unsigned base, uint16_t *ret);
  60
  61 static inline int safe_atou16(const char *s, uint16_t *ret) {
  62         return safe_atou16_full(s, 0, ret);
  63 }
  64
  65 static inline int safe_atoux16(const char *s, uint16_t *ret) {
  66         return safe_atou16_full(s, 16, ret);
  67 }
  68
  69 int safe_atoi16(const char *s, int16_t *ret);
  70
  71 static inline int safe_atou32(const char *s, uint32_t *ret_u) {
  72         assert_cc(sizeof(uint32_t) == sizeof(unsigned));
  73         return safe_atou(s, (unsigned*) ret_u);
  74 }
  75
  76 static inline int safe_atoi32(const char *s, int32_t *ret_i) {
  77         assert_cc(sizeof(int32_t) == sizeof(int));
  78         return safe_atoi(s, (int*) ret_i);
  79 }
  80
  81 static inline int safe_atou64(const char *s, uint64_t *ret_u) {
  82         assert_cc(sizeof(uint64_t) == sizeof(unsigned long long));
  83         return safe_atollu(s, (unsigned long long*) ret_u);
  84 }
  85
  86 static inline int safe_atoi64(const char *s, int64_t *ret_i) {
  87         assert_cc(sizeof(int64_t) == sizeof(long long int));
  88         return safe_atolli(s, (long long int*) ret_i);
  89 }
  90
  91 #if LONG_MAX == INT_MAX
  92 static inline int safe_atolu(const char *s, unsigned long *ret_u) {
  93         assert_cc(sizeof(unsigned long) == sizeof(unsigned));
  94         return safe_atou(s, (unsigned*) ret_u);
  95 }
  96 static inline int safe_atoli(const char *s, long int *ret_u) {
  97         assert_cc(sizeof(long int) == sizeof(int));
  98         return safe_atoi(s, (int*) ret_u);
  99 }
 100 #else
 101 static inline int safe_atolu(const char *s, unsigned long *ret_u) {
 102         assert_cc(sizeof(unsigned long) == sizeof(unsigned long long));
 103         return safe_atollu(s, (unsigned long long*) ret_u);
 104 }
 105 static inline int safe_atoli(const char *s, long int *ret_u) {
 106         assert_cc(sizeof(long int) == sizeof(long long int));
 107         return safe_atolli(s, (long long int*) ret_u);
 108 }
 109 #endif
 110
 111 #if SIZE_MAX == UINT_MAX
 112 static inline int safe_atozu(const char *s, size_t *ret_u) {
 113         assert_cc(sizeof(size_t) == sizeof(unsigned));
 114         return safe_atou(s, (unsigned *) ret_u);
 115 }
 116 #else
 117 static inline int safe_atozu(const char *s, size_t *ret_u) {
 118         assert_cc(sizeof(size_t) == sizeof(long unsigned));
 119         return safe_atolu(s, ret_u);
 120 }
 121 #endif
 122
 123 int safe_atod(const char *s, double *ret_d);
 124
 125 int parse_fractional_part_u(const char **s, size_t digits, unsigned *res);
 126
 127 int parse_percent_unbounded(const char *p);
 128 int parse_percent(const char *p);
 129
 130 int parse_nice(const char *p, int *ret);
 131
 132 int parse_ip_port(const char *s, uint16_t *ret);