ceph/src/common/escape.c

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3 /*
   4  * Ceph - scalable distributed file system
   5  *
   6  * Copyright (C) 2011 New Dream Network
   7  *
   8  * This is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License version 2.1, as published by the Free Software
  11  * Foundation.  See file COPYING.
  12  *
  13  */
  14
  15 #include "common/escape.h"
  16
  17 #include <stdio.h>
  18 #include <string.h>
  19
  20 /*
  21  * Some functions for escaping RGW responses
  22  */
  23
  24 /* Static string length */
  25 #define SSTRL(x) ((sizeof(x)/sizeof(x[0])) - 1)
  26
  27 #define LESS_THAN_XESCAPE               "&lt;"
  28 #define AMPERSAND_XESCAPE               "&amp;"
  29 #define GREATER_THAN_XESCAPE            "&gt;"
  30 #define SGL_QUOTE_XESCAPE               "&apos;"
  31 #define DBL_QUOTE_XESCAPE               "&quot;"
  32
  33 int escape_xml_attr_len(const char *buf)
  34 {
  35         const char *b;
  36         int ret = 0;
  37         for (b = buf; *b; ++b) {
  38                 unsigned char c = *b;
  39                 switch (c) {
  40                 case '<':
  41                         ret += SSTRL(LESS_THAN_XESCAPE);
  42                         break;
  43                 case '&':
  44                         ret += SSTRL(AMPERSAND_XESCAPE);
  45                         break;
  46                 case '>':
  47                         ret += SSTRL(GREATER_THAN_XESCAPE);
  48                         break;
  49                 case '\'':
  50                         ret += SSTRL(SGL_QUOTE_XESCAPE);
  51                         break;
  52                 case '"':
  53                         ret += SSTRL(DBL_QUOTE_XESCAPE);
  54                         break;
  55                 default:
  56                         // Escape control characters.
  57                         if (((c < 0x20) && (c != 0x09) && (c != 0x0a)) ||
  58                                     (c == 0x7f)) {
  59                                 ret += 6;
  60                         }
  61                         else {
  62                                 ret++;
  63                         }
  64                 }
  65         }
  66         // leave room for null terminator
  67         ret++;
  68         return ret;
  69 }
  70
  71 void escape_xml_attr(const char *buf, char *out)
  72 {
  73         char *o = out;
  74         const char *b;
  75         for (b = buf; *b; ++b) {
  76                 unsigned char c = *b;
  77                 switch (c) {
  78                 case '<':
  79                         memcpy(o, LESS_THAN_XESCAPE, SSTRL(LESS_THAN_XESCAPE));
  80                         o += SSTRL(LESS_THAN_XESCAPE);
  81                         break;
  82                 case '&':
  83                         memcpy(o, AMPERSAND_XESCAPE, SSTRL(AMPERSAND_XESCAPE));
  84                         o += SSTRL(AMPERSAND_XESCAPE);
  85                         break;
  86                 case '>':
  87                         memcpy(o, GREATER_THAN_XESCAPE, SSTRL(GREATER_THAN_XESCAPE));
  88                         o += SSTRL(GREATER_THAN_XESCAPE);
  89                         break;
  90                 case '\'':
  91                         memcpy(o, SGL_QUOTE_XESCAPE, SSTRL(SGL_QUOTE_XESCAPE));
  92                         o += SSTRL(SGL_QUOTE_XESCAPE);
  93                         break;
  94                 case '"':
  95                         memcpy(o, DBL_QUOTE_XESCAPE, SSTRL(DBL_QUOTE_XESCAPE));
  96                         o += SSTRL(DBL_QUOTE_XESCAPE);
  97                         break;
  98                 default:
  99                         // Escape control characters.
 100                         if (((c < 0x20) && (c != 0x09) && (c != 0x0a)) ||
 101                                     (c == 0x7f)) {
 102                                 snprintf(o, 7, "&#x%02x;", c);
 103                                 o += 6;
 104                         }
 105                         else {
 106                                 *o++ = c;
 107                         }
 108                         break;
 109                 }
 110         }
 111         // null terminator
 112         *o = '\0';
 113 }
 114
 115 #define DBL_QUOTE_JESCAPE "\\\""
 116 #define BACKSLASH_JESCAPE "\\\\"
 117 #define TAB_JESCAPE "\\t"
 118 #define NEWLINE_JESCAPE "\\n"
 119
 120 int escape_json_attr_len(const char *buf, int src_len)
 121 {
 122         const char *b;
 123         int ret = 0;
 124         int i;
 125         for (i = 0, b = buf; i < src_len; ++i, ++b) {
 126                 unsigned char c = *b;
 127                 switch (c) {
 128                 case '"':
 129                         ret += SSTRL(DBL_QUOTE_JESCAPE);
 130                         break;
 131                 case '\\':
 132                         ret += SSTRL(BACKSLASH_JESCAPE);
 133                         break;
 134                 case '\t':
 135                         ret += SSTRL(TAB_JESCAPE);
 136                         break;
 137                 case '\n':
 138                         ret += SSTRL(NEWLINE_JESCAPE);
 139                         break;
 140                 default:
 141                         // Escape control characters.
 142                         if ((c < 0x20) || (c == 0x7f)) {
 143                                 ret += 6;
 144                         }
 145                         else {
 146                                 ret++;
 147                         }
 148                 }
 149         }
 150         // leave room for null terminator
 151         ret++;
 152         return ret;
 153 }
 154
 155 void escape_json_attr(const char *buf, int src_len, char *out)
 156 {
 157         char *o = out;
 158         const char *b;
 159         int i;
 160         for (i = 0, b = buf; i < src_len; ++i, ++b) {
 161                 unsigned char c = *b;
 162                 switch (c) {
 163                 case '"':
 164                         // cppcheck-suppress invalidFunctionArg
 165                         memcpy(o, DBL_QUOTE_JESCAPE, SSTRL(DBL_QUOTE_JESCAPE));
 166                         o += SSTRL(DBL_QUOTE_JESCAPE);
 167                         break;
 168                 case '\\':
 169                         // cppcheck-suppress invalidFunctionArg
 170                         memcpy(o, BACKSLASH_JESCAPE, SSTRL(BACKSLASH_JESCAPE));
 171                         o += SSTRL(BACKSLASH_JESCAPE);
 172                         break;
 173                 case '\t':
 174                         // cppcheck-suppress invalidFunctionArg
 175                         memcpy(o, TAB_JESCAPE, SSTRL(TAB_JESCAPE));
 176                         o += SSTRL(TAB_JESCAPE);
 177                         break;
 178                 case '\n':
 179                         // cppcheck-suppress invalidFunctionArg
 180                         memcpy(o, NEWLINE_JESCAPE, SSTRL(NEWLINE_JESCAPE));
 181                         o += SSTRL(NEWLINE_JESCAPE);
 182                         break;
 183                 default:
 184                         // Escape control characters.
 185                         if ((c < 0x20) || (c == 0x7f)) {
 186                                 snprintf(o, 7, "\\u%04x", c);
 187                                 o += 6;
 188                         }
 189                         else {
 190                                 *o++ = c;
 191                         }
 192                         break;
 193                 }
 194         }
 195         // null terminator
 196         *o = '\0';
 197 }
 198