src/libelogind/sd-bus/bus-type.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3 ***/
   4
   5 #include <errno.h>
   6
   7 #include "sd-bus.h"
   8
   9 #include "bus-type.h"
  10
  11 bool bus_type_is_valid(char c) {
  12         static const char valid[] = {
  13                 SD_BUS_TYPE_BYTE,
  14                 SD_BUS_TYPE_BOOLEAN,
  15                 SD_BUS_TYPE_INT16,
  16                 SD_BUS_TYPE_UINT16,
  17                 SD_BUS_TYPE_INT32,
  18                 SD_BUS_TYPE_UINT32,
  19                 SD_BUS_TYPE_INT64,
  20                 SD_BUS_TYPE_UINT64,
  21                 SD_BUS_TYPE_DOUBLE,
  22                 SD_BUS_TYPE_STRING,
  23                 SD_BUS_TYPE_OBJECT_PATH,
  24                 SD_BUS_TYPE_SIGNATURE,
  25                 SD_BUS_TYPE_ARRAY,
  26                 SD_BUS_TYPE_VARIANT,
  27                 SD_BUS_TYPE_STRUCT,
  28                 SD_BUS_TYPE_DICT_ENTRY,
  29                 SD_BUS_TYPE_UNIX_FD
  30         };
  31
  32         return !!memchr(valid, c, sizeof(valid));
  33 }
  34
  35 #if 0 /// UNNEEDED by elogind
  36 bool bus_type_is_valid_in_signature(char c) {
  37         static const char valid[] = {
  38                 SD_BUS_TYPE_BYTE,
  39                 SD_BUS_TYPE_BOOLEAN,
  40                 SD_BUS_TYPE_INT16,
  41                 SD_BUS_TYPE_UINT16,
  42                 SD_BUS_TYPE_INT32,
  43                 SD_BUS_TYPE_UINT32,
  44                 SD_BUS_TYPE_INT64,
  45                 SD_BUS_TYPE_UINT64,
  46                 SD_BUS_TYPE_DOUBLE,
  47                 SD_BUS_TYPE_STRING,
  48                 SD_BUS_TYPE_OBJECT_PATH,
  49                 SD_BUS_TYPE_SIGNATURE,
  50                 SD_BUS_TYPE_ARRAY,
  51                 SD_BUS_TYPE_VARIANT,
  52                 SD_BUS_TYPE_STRUCT_BEGIN,
  53                 SD_BUS_TYPE_STRUCT_END,
  54                 SD_BUS_TYPE_DICT_ENTRY_BEGIN,
  55                 SD_BUS_TYPE_DICT_ENTRY_END,
  56                 SD_BUS_TYPE_UNIX_FD
  57         };
  58
  59         return !!memchr(valid, c, sizeof(valid));
  60 }
  61 #endif // 0
  62
  63 bool bus_type_is_basic(char c) {
  64         static const char valid[] = {
  65                 SD_BUS_TYPE_BYTE,
  66                 SD_BUS_TYPE_BOOLEAN,
  67                 SD_BUS_TYPE_INT16,
  68                 SD_BUS_TYPE_UINT16,
  69                 SD_BUS_TYPE_INT32,
  70                 SD_BUS_TYPE_UINT32,
  71                 SD_BUS_TYPE_INT64,
  72                 SD_BUS_TYPE_UINT64,
  73                 SD_BUS_TYPE_DOUBLE,
  74                 SD_BUS_TYPE_STRING,
  75                 SD_BUS_TYPE_OBJECT_PATH,
  76                 SD_BUS_TYPE_SIGNATURE,
  77                 SD_BUS_TYPE_UNIX_FD
  78         };
  79
  80         return !!memchr(valid, c, sizeof(valid));
  81 }
  82
  83 bool bus_type_is_trivial(char c) {
  84         static const char valid[] = {
  85                 SD_BUS_TYPE_BYTE,
  86                 SD_BUS_TYPE_BOOLEAN,
  87                 SD_BUS_TYPE_INT16,
  88                 SD_BUS_TYPE_UINT16,
  89                 SD_BUS_TYPE_INT32,
  90                 SD_BUS_TYPE_UINT32,
  91                 SD_BUS_TYPE_INT64,
  92                 SD_BUS_TYPE_UINT64,
  93                 SD_BUS_TYPE_DOUBLE
  94         };
  95
  96         return !!memchr(valid, c, sizeof(valid));
  97 }
  98
  99 bool bus_type_is_container(char c) {
 100         static const char valid[] = {
 101                 SD_BUS_TYPE_ARRAY,
 102                 SD_BUS_TYPE_VARIANT,
 103                 SD_BUS_TYPE_STRUCT,
 104                 SD_BUS_TYPE_DICT_ENTRY
 105         };
 106
 107         return !!memchr(valid, c, sizeof(valid));
 108 }
 109
 110 int bus_type_get_alignment(char c) {
 111
 112         switch (c) {
 113         case SD_BUS_TYPE_BYTE:
 114         case SD_BUS_TYPE_SIGNATURE:
 115         case SD_BUS_TYPE_VARIANT:
 116                 return 1;
 117
 118         case SD_BUS_TYPE_INT16:
 119         case SD_BUS_TYPE_UINT16:
 120                 return 2;
 121
 122         case SD_BUS_TYPE_BOOLEAN:
 123         case SD_BUS_TYPE_INT32:
 124         case SD_BUS_TYPE_UINT32:
 125         case SD_BUS_TYPE_STRING:
 126         case SD_BUS_TYPE_OBJECT_PATH:
 127         case SD_BUS_TYPE_ARRAY:
 128         case SD_BUS_TYPE_UNIX_FD:
 129                 return 4;
 130
 131         case SD_BUS_TYPE_INT64:
 132         case SD_BUS_TYPE_UINT64:
 133         case SD_BUS_TYPE_DOUBLE:
 134         case SD_BUS_TYPE_STRUCT:
 135         case SD_BUS_TYPE_STRUCT_BEGIN:
 136         case SD_BUS_TYPE_DICT_ENTRY:
 137         case SD_BUS_TYPE_DICT_ENTRY_BEGIN:
 138                 return 8;
 139         }
 140
 141         return -EINVAL;
 142 }
 143
 144 int bus_type_get_size(char c) {
 145
 146         switch (c) {
 147         case SD_BUS_TYPE_BYTE:
 148                 return 1;
 149
 150         case SD_BUS_TYPE_INT16:
 151         case SD_BUS_TYPE_UINT16:
 152                 return 2;
 153
 154         case SD_BUS_TYPE_BOOLEAN:
 155         case SD_BUS_TYPE_INT32:
 156         case SD_BUS_TYPE_UINT32:
 157         case SD_BUS_TYPE_UNIX_FD:
 158                 return 4;
 159
 160         case SD_BUS_TYPE_INT64:
 161         case SD_BUS_TYPE_UINT64:
 162         case SD_BUS_TYPE_DOUBLE:
 163                 return 8;
 164         }
 165
 166         return -EINVAL;
 167 }