selinux: Remove security_ops extern

[linux.git] / lib / string_helpers.c

diff --git a/lib/string_helpers.c b/lib/string_helpers.c
index 8347925030ff51a0a98d1a81cb5ae9c0b06413fa..ed5c1454dd6288aacf85e4ee7db5e2e3ee947627 100644 (file)
--- a/lib/string_helpers.c
+++ b/lib/string_helpers.c
@@ -2,10 +2,12 @@
  * Helpers for formatting and printing strings
  *
  * Copyright 31 August 2008 James Bottomley
+ * Copyright (C) 2013, Intel Corporation
  */
 #include <linux/kernel.h>
 #include <linux/math64.h>
-#include <linux/module.h>
+#include <linux/export.h>
+#include <linux/ctype.h>
 #include <linux/string_helpers.h>
 
 /**
@@ -23,15 +25,15 @@
 int string_get_size(u64 size, const enum string_size_units units,
                    char *buf, int len)
 {
-       const char *units_10[] = { "B", "KB", "MB", "GB", "TB", "PB",
+       static const char *units_10[] = { "B", "kB", "MB", "GB", "TB", "PB",
                                   "EB", "ZB", "YB", NULL};
-       const char *units_2[] = {"B", "KiB", "MiB", "GiB", "TiB", "PiB",
+       static const char *units_2[] = {"B", "KiB", "MiB", "GiB", "TiB", "PiB",
                                 "EiB", "ZiB", "YiB", NULL };
-       const char **units_str[] = {
+       static const char **units_str[] = {
                [STRING_UNITS_10] =  units_10,
                [STRING_UNITS_2] = units_2,
        };
-       const int divisor[] = {
+       static const unsigned int divisor[] = {
                [STRING_UNITS_10] = 1000,
                [STRING_UNITS_2] = 1024,
        };
@@ -40,25 +42,160 @@ int string_get_size(u64 size, const enum string_size_units units,
        char tmp[8];
 
        tmp[0] = '\0';
+       i = 0;
+       if (size >= divisor[units]) {
+               while (size >= divisor[units] && units_str[units][i]) {
+                       remainder = do_div(size, divisor[units]);
+                       i++;
+               }
 
-       for (i = 0; size > divisor[units] && units_str[units][i]; i++)
-               remainder = do_div(size, divisor[units]);
+               sf_cap = size;
+               for (j = 0; sf_cap*10 < 1000; j++)
+                       sf_cap *= 10;
 
-       sf_cap = size;
-       for (j = 0; sf_cap*10 < 1000; j++)
-               sf_cap *= 10;
-
-       if (j) {
-               remainder *= 1000;
-               do_div(remainder, divisor[units]);
-               snprintf(tmp, sizeof(tmp), ".%03lld",
-                        (unsigned long long)remainder);
-               tmp[j+1] = '\0';
+               if (j) {
+                       remainder *= 1000;
+                       do_div(remainder, divisor[units]);
+                       snprintf(tmp, sizeof(tmp), ".%03lld",
+                                (unsigned long long)remainder);
+                       tmp[j+1] = '\0';
+               }
        }
 
-       snprintf(buf, len, "%lld%s%s", (unsigned long long)size,
+       snprintf(buf, len, "%lld%s %s", (unsigned long long)size,
                 tmp, units_str[units][i]);
 
        return 0;
 }
 EXPORT_SYMBOL(string_get_size);
+
+static bool unescape_space(char **src, char **dst)
+{
+       char *p = *dst, *q = *src;
+
+       switch (*q) {
+       case 'n':
+               *p = '\n';
+               break;
+       case 'r':
+               *p = '\r';
+               break;
+       case 't':
+               *p = '\t';
+               break;
+       case 'v':
+               *p = '\v';
+               break;
+       case 'f':
+               *p = '\f';
+               break;
+       default:
+               return false;
+       }
+       *dst += 1;
+       *src += 1;
+       return true;
+}
+
+static bool unescape_octal(char **src, char **dst)
+{
+       char *p = *dst, *q = *src;
+       u8 num;
+
+       if (isodigit(*q) == 0)
+               return false;
+
+       num = (*q++) & 7;
+       while (num < 32 && isodigit(*q) && (q - *src < 3)) {
+               num <<= 3;
+               num += (*q++) & 7;
+       }
+       *p = num;
+       *dst += 1;
+       *src = q;
+       return true;
+}
+
+static bool unescape_hex(char **src, char **dst)
+{
+       char *p = *dst, *q = *src;
+       int digit;
+       u8 num;
+
+       if (*q++ != 'x')
+               return false;
+
+       num = digit = hex_to_bin(*q++);
+       if (digit < 0)
+               return false;
+
+       digit = hex_to_bin(*q);
+       if (digit >= 0) {
+               q++;
+               num = (num << 4) | digit;
+       }
+       *p = num;
+       *dst += 1;
+       *src = q;
+       return true;
+}
+
+static bool unescape_special(char **src, char **dst)
+{
+       char *p = *dst, *q = *src;
+
+       switch (*q) {
+       case '\"':
+               *p = '\"';
+               break;
+       case '\\':
+               *p = '\\';
+               break;
+       case 'a':
+               *p = '\a';
+               break;
+       case 'e':
+               *p = '\e';
+               break;
+       default:
+               return false;
+       }
+       *dst += 1;
+       *src += 1;
+       return true;
+}
+
+int string_unescape(char *src, char *dst, size_t size, unsigned int flags)
+{
+       char *out = dst;
+
+       while (*src && --size) {
+               if (src[0] == '\\' && src[1] != '\0' && size > 1) {
+                       src++;
+                       size--;
+
+                       if (flags & UNESCAPE_SPACE &&
+                                       unescape_space(&src, &out))
+                               continue;
+
+                       if (flags & UNESCAPE_OCTAL &&
+                                       unescape_octal(&src, &out))
+                               continue;
+
+                       if (flags & UNESCAPE_HEX &&
+                                       unescape_hex(&src, &out))
+                               continue;
+
+                       if (flags & UNESCAPE_SPECIAL &&
+                                       unescape_special(&src, &out))
+                               continue;
+
+                       *out++ = '\\';
+               }
+               *out++ = *src++;
+       }
+       *out = '\0';
+
+       return out - dst;
+}
+EXPORT_SYMBOL(string_unescape);