LCOV - code coverage report
Current view: top level - systemd - sd-id128.h (source / functions) Hit Total Coverage
Test: systemd test coverage Lines: 2 2 100.0 %
Date: 2015-07-29 18:47:03 Functions: 1 1 100.0 %

          Line data    Source code
       1             : /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
       2             : 
       3             : #ifndef foosdid128hfoo
       4             : #define foosdid128hfoo
       5             : 
       6             : /***
       7             :   This file is part of systemd.
       8             : 
       9             :   Copyright 2011 Lennart Poettering
      10             : 
      11             :   systemd is free software; you can redistribute it and/or modify it
      12             :   under the terms of the GNU Lesser General Public License as published by
      13             :   the Free Software Foundation; either version 2.1 of the License, or
      14             :   (at your option) any later version.
      15             : 
      16             :   systemd is distributed in the hope that it will be useful, but
      17             :   WITHOUT ANY WARRANTY; without even the implied warranty of
      18             :   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
      19             :   Lesser General Public License for more details.
      20             : 
      21             :   You should have received a copy of the GNU Lesser General Public License
      22             :   along with systemd; If not, see <http://www.gnu.org/licenses/>.
      23             : ***/
      24             : 
      25             : #include <inttypes.h>
      26             : #include <string.h>
      27             : 
      28             : #include "_sd-common.h"
      29             : 
      30             : _SD_BEGIN_DECLARATIONS;
      31             : 
      32             : /* 128-bit ID APIs. See sd-id128(3) for more information. */
      33             : 
      34             : typedef union sd_id128 sd_id128_t;
      35             : 
      36             : union sd_id128 {
      37             :         uint8_t bytes[16];
      38             :         uint64_t qwords[2];
      39             : };
      40             : 
      41             : #define SD_ID128_STRING_MAX 33
      42             : 
      43             : char *sd_id128_to_string(sd_id128_t id, char s[SD_ID128_STRING_MAX]);
      44             : 
      45             : int sd_id128_from_string(const char *s, sd_id128_t *ret);
      46             : 
      47             : int sd_id128_randomize(sd_id128_t *ret);
      48             : 
      49             : int sd_id128_get_machine(sd_id128_t *ret);
      50             : 
      51             : int sd_id128_get_boot(sd_id128_t *ret);
      52             : 
      53             : #define SD_ID128_MAKE(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) \
      54             :         ((const sd_id128_t) { .bytes = { 0x##v0, 0x##v1, 0x##v2, 0x##v3, 0x##v4, 0x##v5, 0x##v6, 0x##v7, \
      55             :                                    0x##v8, 0x##v9, 0x##v10, 0x##v11, 0x##v12, 0x##v13, 0x##v14, 0x##v15 }})
      56             : 
      57             : #define SD_ID128_ARRAY(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) \
      58             :         { .bytes = { 0x##v0, 0x##v1, 0x##v2, 0x##v3, 0x##v4, 0x##v5, 0x##v6, 0x##v7, \
      59             :                      0x##v8, 0x##v9, 0x##v10, 0x##v11, 0x##v12, 0x##v13, 0x##v14, 0x##v15 }}
      60             : 
      61             : /* Note that SD_ID128_FORMAT_VAL will evaluate the passed argument 16
      62             :  * times. It is hence not a good idea to call this macro with an
      63             :  * expensive function as parameter or an expression with side
      64             :  * effects */
      65             : 
      66             : #define SD_ID128_FORMAT_STR "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x"
      67             : #define SD_ID128_FORMAT_VAL(x) (x).bytes[0], (x).bytes[1], (x).bytes[2], (x).bytes[3], (x).bytes[4], (x).bytes[5], (x).bytes[6], (x).bytes[7], (x).bytes[8], (x).bytes[9], (x).bytes[10], (x).bytes[11], (x).bytes[12], (x).bytes[13], (x).bytes[14], (x).bytes[15]
      68             : 
      69             : #define SD_ID128_CONST_STR(x)                                           \
      70             :         ((const char[SD_ID128_STRING_MAX]) {                            \
      71             :                 ((x).bytes[0] >> 4) >= 10 ? 'a' + ((x).bytes[0] >> 4) - 10 : '0' + ((x).bytes[0] >> 4), \
      72             :                 ((x).bytes[0] & 15) >= 10 ? 'a' + ((x).bytes[0] & 15) - 10 : '0' + ((x).bytes[0] & 15), \
      73             :                 ((x).bytes[1] >> 4) >= 10 ? 'a' + ((x).bytes[1] >> 4) - 10 : '0' + ((x).bytes[1] >> 4), \
      74             :                 ((x).bytes[1] & 15) >= 10 ? 'a' + ((x).bytes[1] & 15) - 10 : '0' + ((x).bytes[1] & 15), \
      75             :                 ((x).bytes[2] >> 4) >= 10 ? 'a' + ((x).bytes[2] >> 4) - 10 : '0' + ((x).bytes[2] >> 4), \
      76             :                 ((x).bytes[2] & 15) >= 10 ? 'a' + ((x).bytes[2] & 15) - 10 : '0' + ((x).bytes[2] & 15), \
      77             :                 ((x).bytes[3] >> 4) >= 10 ? 'a' + ((x).bytes[3] >> 4) - 10 : '0' + ((x).bytes[3] >> 4), \
      78             :                 ((x).bytes[3] & 15) >= 10 ? 'a' + ((x).bytes[3] & 15) - 10 : '0' + ((x).bytes[3] & 15), \
      79             :                 ((x).bytes[4] >> 4) >= 10 ? 'a' + ((x).bytes[4] >> 4) - 10 : '0' + ((x).bytes[4] >> 4), \
      80             :                 ((x).bytes[4] & 15) >= 10 ? 'a' + ((x).bytes[4] & 15) - 10 : '0' + ((x).bytes[4] & 15), \
      81             :                 ((x).bytes[5] >> 4) >= 10 ? 'a' + ((x).bytes[5] >> 4) - 10 : '0' + ((x).bytes[5] >> 4), \
      82             :                 ((x).bytes[5] & 15) >= 10 ? 'a' + ((x).bytes[5] & 15) - 10 : '0' + ((x).bytes[5] & 15), \
      83             :                 ((x).bytes[6] >> 4) >= 10 ? 'a' + ((x).bytes[6] >> 4) - 10 : '0' + ((x).bytes[6] >> 4), \
      84             :                 ((x).bytes[6] & 15) >= 10 ? 'a' + ((x).bytes[6] & 15) - 10 : '0' + ((x).bytes[6] & 15), \
      85             :                 ((x).bytes[7] >> 4) >= 10 ? 'a' + ((x).bytes[7] >> 4) - 10 : '0' + ((x).bytes[7] >> 4), \
      86             :                 ((x).bytes[7] & 15) >= 10 ? 'a' + ((x).bytes[7] & 15) - 10 : '0' + ((x).bytes[7] & 15), \
      87             :                 ((x).bytes[8] >> 4) >= 10 ? 'a' + ((x).bytes[8] >> 4) - 10 : '0' + ((x).bytes[8] >> 4), \
      88             :                 ((x).bytes[8] & 15) >= 10 ? 'a' + ((x).bytes[8] & 15) - 10 : '0' + ((x).bytes[8] & 15), \
      89             :                 ((x).bytes[9] >> 4) >= 10 ? 'a' + ((x).bytes[9] >> 4) - 10 : '0' + ((x).bytes[9] >> 4), \
      90             :                 ((x).bytes[9] & 15) >= 10 ? 'a' + ((x).bytes[9] & 15) - 10 : '0' + ((x).bytes[9] & 15), \
      91             :                 ((x).bytes[10] >> 4) >= 10 ? 'a' + ((x).bytes[10] >> 4) - 10 : '0' + ((x).bytes[10] >> 4), \
      92             :                 ((x).bytes[10] & 15) >= 10 ? 'a' + ((x).bytes[10] & 15) - 10 : '0' + ((x).bytes[10] & 15), \
      93             :                 ((x).bytes[11] >> 4) >= 10 ? 'a' + ((x).bytes[11] >> 4) - 10 : '0' + ((x).bytes[11] >> 4), \
      94             :                 ((x).bytes[11] & 15) >= 10 ? 'a' + ((x).bytes[11] & 15) - 10 : '0' + ((x).bytes[11] & 15), \
      95             :                 ((x).bytes[12] >> 4) >= 10 ? 'a' + ((x).bytes[12] >> 4) - 10 : '0' + ((x).bytes[12] >> 4), \
      96             :                 ((x).bytes[12] & 15) >= 10 ? 'a' + ((x).bytes[12] & 15) - 10 : '0' + ((x).bytes[12] & 15), \
      97             :                 ((x).bytes[13] >> 4) >= 10 ? 'a' + ((x).bytes[13] >> 4) - 10 : '0' + ((x).bytes[13] >> 4), \
      98             :                 ((x).bytes[13] & 15) >= 10 ? 'a' + ((x).bytes[13] & 15) - 10 : '0' + ((x).bytes[13] & 15), \
      99             :                 ((x).bytes[14] >> 4) >= 10 ? 'a' + ((x).bytes[14] >> 4) - 10 : '0' + ((x).bytes[14] >> 4), \
     100             :                 ((x).bytes[14] & 15) >= 10 ? 'a' + ((x).bytes[14] & 15) - 10 : '0' + ((x).bytes[14] & 15), \
     101             :                 ((x).bytes[15] >> 4) >= 10 ? 'a' + ((x).bytes[15] >> 4) - 10 : '0' + ((x).bytes[15] >> 4), \
     102             :                 ((x).bytes[15] & 15) >= 10 ? 'a' + ((x).bytes[15] & 15) - 10 : '0' + ((x).bytes[15] & 15), \
     103             :                 0 })
     104             : 
     105      271799 : _sd_pure_ static inline int sd_id128_equal(sd_id128_t a, sd_id128_t b) {
     106      271799 :         return memcmp(&a, &b, 16) == 0;
     107             : }
     108             : 
     109             : _sd_pure_ static inline int sd_id128_is_null(sd_id128_t a) {
     110             :         return a.qwords[0] == 0 && a.qwords[1] == 0;
     111             : }
     112             : 
     113             : #define SD_ID128_NULL ((const sd_id128_t) { .qwords = { 0, 0 }})
     114             : 
     115             : _SD_END_DECLARATIONS;
     116             : 
     117             : #endif

Generated by: LCOV version 1.11