Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: LGPL-2.1+ */
       2                 :            : 
       3                 :            : #include <stdlib.h>
       4                 :            : 
       5                 :            : #include "alloc-util.h"
       6                 :            : #include "bus-label.h"
       7                 :            : #include "hexdecoct.h"
       8                 :            : #include "macro.h"
       9                 :            : 
      10                 :         56 : char *bus_label_escape(const char *s) {
      11                 :            :         char *r, *t;
      12                 :            :         const char *f;
      13                 :            : 
      14   [ -  +  -  + ]:         56 :         assert_return(s, NULL);
      15                 :            : 
      16                 :            :         /* Escapes all chars that D-Bus' object path cannot deal
      17                 :            :          * with. Can be reversed with bus_path_unescape(). We special
      18                 :            :          * case the empty string. */
      19                 :            : 
      20         [ +  + ]:         56 :         if (*s == 0)
      21                 :          8 :                 return strdup("_");
      22                 :            : 
      23                 :         48 :         r = new(char, strlen(s)*3 + 1);
      24         [ -  + ]:         48 :         if (!r)
      25                 :          0 :                 return NULL;
      26                 :            : 
      27         [ +  + ]:        312 :         for (f = s, t = r; *f; f++) {
      28                 :            : 
      29                 :            :                 /* Escape everything that is not a-zA-Z0-9. We also
      30                 :            :                  * escape 0-9 if it's the first character */
      31                 :            : 
      32   [ +  +  +  - ]:        264 :                 if (!(*f >= 'A' && *f <= 'Z') &&
      33   [ +  +  -  +  :        264 :                     !(*f >= 'a' && *f <= 'z') &&
                   +  + ]
      34   [ +  +  +  + ]:         40 :                     !(f > s && *f >= '0' && *f <= '9')) {
      35                 :         32 :                         *(t++) = '_';
      36                 :         32 :                         *(t++) = hexchar(*f >> 4);
      37                 :         32 :                         *(t++) = hexchar(*f);
      38                 :            :                 } else
      39                 :        232 :                         *(t++) = *f;
      40                 :            :         }
      41                 :            : 
      42                 :         48 :         *t = 0;
      43                 :            : 
      44                 :         48 :         return r;
      45                 :            : }
      46                 :            : 
      47                 :       1320 : char *bus_label_unescape_n(const char *f, size_t l) {
      48                 :            :         char *r, *t;
      49                 :            :         size_t i;
      50                 :            : 
      51   [ -  +  -  + ]:       1320 :         assert_return(f, NULL);
      52                 :            : 
      53                 :            :         /* Special case for the empty string */
      54   [ +  +  +  - ]:       1320 :         if (l == 1 && *f == '_')
      55                 :         20 :                 return strdup("");
      56                 :            : 
      57                 :       1300 :         r = new(char, l + 1);
      58         [ -  + ]:       1300 :         if (!r)
      59                 :          0 :                 return NULL;
      60                 :            : 
      61         [ +  + ]:      36776 :         for (i = 0, t = r; i < l; ++i) {
      62         [ +  + ]:      35476 :                 if (f[i] == '_') {
      63                 :            :                         int a, b;
      64                 :            : 
      65         [ +  - ]:       4612 :                         if (l - i < 3 ||
      66         [ +  - ]:       4612 :                             (a = unhexchar(f[i + 1])) < 0 ||
      67         [ -  + ]:       4612 :                             (b = unhexchar(f[i + 2])) < 0) {
      68                 :            :                                 /* Invalid escape code, let's take it literal then */
      69                 :          0 :                                 *(t++) = '_';
      70                 :            :                         } else {
      71                 :       4612 :                                 *(t++) = (char) ((a << 4) | b);
      72                 :       4612 :                                 i += 2;
      73                 :            :                         }
      74                 :            :                 } else
      75                 :      30864 :                         *(t++) = f[i];
      76                 :            :         }
      77                 :            : 
      78                 :       1300 :         *t = 0;
      79                 :            : 
      80                 :       1300 :         return r;
      81                 :            : }