lib/mangle.c

   1 /*
   2  * Functions for \oct encoding used in mtab/fstab/swaps/etc.
   3  *
   4  * No copyright is claimed.  This code is in the public domain; do with
   5  * it what you wish.
   6  *
   7  * Copyright (C) 2010 Karel Zak <kzak@redhat.com>
   8  */
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <ctype.h>
  13
  14 #include "mangle.h"
  15 #include "c.h"
  16
  17 #define isoctal(a)              (((a) & ~7) == '0')
  18
  19 #define from_hex(c)             (isdigit(c) ? c - '0' : tolower(c) - 'a' + 10)
  20
  21 #define is_unwanted_char(x)     (strchr(" \t\n\\", (unsigned int) x) != NULL)
  22
  23
  24 char *mangle(const char *s)
  25 {
  26         char *ss, *sp;
  27
  28         if (!s)
  29                 return NULL;
  30
  31         ss = sp = malloc(4 * strlen(s) + 1);
  32         if (!sp)
  33                 return NULL;
  34         while(1) {
  35                 if (!*s) {
  36                         *sp = '\0';
  37                         break;
  38                 }
  39                 if (is_unwanted_char(*s)) {
  40                         *sp++ = '\\';
  41                         *sp++ = '0' + ((*s & 0300) >> 6);
  42                         *sp++ = '0' + ((*s & 070) >> 3);
  43                         *sp++ = '0' + (*s & 07);
  44                 } else
  45                         *sp++ = *s;
  46                 s++;
  47         }
  48         return ss;
  49 }
  50
  51
  52 void unmangle_to_buffer(const char *s, char *buf, size_t len)
  53 {
  54         size_t sz = 0;
  55
  56         if (!s)
  57                 return;
  58
  59         while(*s && sz < len - 1) {
  60                 if (*s == '\\' && sz + 3 < len - 1 && isoctal(s[1]) &&
  61                     isoctal(s[2]) && isoctal(s[3])) {
  62
  63                         *buf++ = 64*(s[1] & 7) + 8*(s[2] & 7) + (s[3] & 7);
  64                         s += 4;
  65                         sz += 4;
  66                 } else {
  67                         *buf++ = *s++;
  68                         sz++;
  69                 }
  70         }
  71         *buf = '\0';
  72 }
  73
  74 size_t unhexmangle_to_buffer(const char *s, char *buf, size_t len)
  75 {
  76         size_t sz = 0;
  77         const char *buf0 = buf;
  78
  79         if (!s)
  80                 return 0;
  81
  82         while(*s && sz < len - 1) {
  83                 if (*s == '\\' && sz + 3 < len - 1 && s[1] == 'x' &&
  84                     isxdigit(s[2]) && isxdigit(s[3])) {
  85
  86                         *buf++ = from_hex(s[2]) << 4 | from_hex(s[3]);
  87                         s += 4;
  88                         sz += 4;
  89                 } else {
  90                         *buf++ = *s++;
  91                         sz++;
  92                 }
  93         }
  94         *buf = '\0';
  95         return buf - buf0 + 1;
  96 }
  97
  98 static inline const char *skip_nonspaces(const char *s)
  99 {
 100         while (s && *s && !(*s == ' ' || *s == '\t'))
 101                 s++;
 102         return s;
 103 }
 104
 105 /*
 106  * Returns mallocated buffer or NULL in case of error.
 107  */
 108 char *unmangle(const char *s, const char **end)
 109 {
 110         char *buf;
 111         const char *e;
 112         size_t sz;
 113
 114         if (!s)
 115                 return NULL;
 116
 117         e = skip_nonspaces(s);
 118         sz = e - s + 1;
 119
 120         if (end)
 121                 *end = e;
 122         if (e == s)
 123                 return NULL;    /* empty string */
 124
 125         buf = malloc(sz);
 126         if (!buf)
 127                 return NULL;
 128
 129         unmangle_to_buffer(s, buf, sz);
 130         return buf;
 131 }
 132
 133 #ifdef TEST_PROGRAM_MANGLE
 134 #include <errno.h>
 135 int main(int argc, char *argv[])
 136 {
 137         char *p = NULL;
 138         if (argc < 3) {
 139                 fprintf(stderr, "usage: %s --mangle|unmangle <string>\n",
 140                                                 program_invocation_short_name);
 141                 return EXIT_FAILURE;
 142         }
 143
 144         if (!strcmp(argv[1], "--mangle")) {
 145                 p = mangle(argv[2]);
 146                 printf("mangled: '%s'\n", p);
 147                 free(p);
 148         }
 149
 150         else if (!strcmp(argv[1], "--unmangle")) {
 151                 char *x = unmangle(argv[2], NULL);
 152
 153                 if (x) {
 154                         printf("unmangled: '%s'\n", x);
 155                         free(x);
 156                 }
 157
 158                 x = strdup(argv[2]);
 159                 if (x) {
 160                         unmangle_to_buffer(x, x, strlen(x) + 1);
 161
 162                         printf("self-unmangled: '%s'\n", x);
 163                         free(x);
 164                 }
 165         }
 166
 167         return EXIT_SUCCESS;
 168 }
 169 #endif /* TEST_PROGRAM_MANGLE */