Line data    Source code

       1             : /* SPDX-License-Identifier: GPL-2.0 */
       2             : #ifndef _LINUX_STRING_HELPERS_H_
       3             : #define _LINUX_STRING_HELPERS_H_
       4             : 
       5             : #include <linux/ctype.h>
       6             : #include <linux/types.h>
       7             : 
       8             : struct file;
       9             : struct task_struct;
      10             : 
      11             : /* Descriptions of the types of units to
      12             :  * print in */
      13             : enum string_size_units {
      14             :         STRING_UNITS_10,        /* use powers of 10^3 (standard SI) */
      15             :         STRING_UNITS_2,         /* use binary powers of 2^10 */
      16             : };
      17             : 
      18             : void string_get_size(u64 size, u64 blk_size, enum string_size_units units,
      19             :                      char *buf, int len);
      20             : 
      21             : #define UNESCAPE_SPACE          0x01
      22             : #define UNESCAPE_OCTAL          0x02
      23             : #define UNESCAPE_HEX            0x04
      24             : #define UNESCAPE_SPECIAL        0x08
      25             : #define UNESCAPE_ANY            \
      26             :         (UNESCAPE_SPACE | UNESCAPE_OCTAL | UNESCAPE_HEX | UNESCAPE_SPECIAL)
      27             : 
      28             : int string_unescape(char *src, char *dst, size_t size, unsigned int flags);
      29             : 
      30             : static inline int string_unescape_inplace(char *buf, unsigned int flags)
      31             : {
      32             :         return string_unescape(buf, buf, 0, flags);
      33             : }
      34             : 
      35             : static inline int string_unescape_any(char *src, char *dst, size_t size)
      36             : {
      37             :         return string_unescape(src, dst, size, UNESCAPE_ANY);
      38             : }
      39             : 
      40             : static inline int string_unescape_any_inplace(char *buf)
      41             : {
      42             :         return string_unescape_any(buf, buf, 0);
      43             : }
      44             : 
      45             : #define ESCAPE_SPACE            0x01
      46             : #define ESCAPE_SPECIAL          0x02
      47             : #define ESCAPE_NULL             0x04
      48             : #define ESCAPE_OCTAL            0x08
      49             : #define ESCAPE_ANY              \
      50             :         (ESCAPE_SPACE | ESCAPE_OCTAL | ESCAPE_SPECIAL | ESCAPE_NULL)
      51             : #define ESCAPE_NP               0x10
      52             : #define ESCAPE_ANY_NP           (ESCAPE_ANY | ESCAPE_NP)
      53             : #define ESCAPE_HEX              0x20
      54             : 
      55             : int string_escape_mem(const char *src, size_t isz, char *dst, size_t osz,
      56             :                 unsigned int flags, const char *only);
      57             : 
      58             : int string_escape_mem_ascii(const char *src, size_t isz, char *dst,
      59             :                                         size_t osz);
      60             : 
      61             : static inline int string_escape_mem_any_np(const char *src, size_t isz,
      62             :                 char *dst, size_t osz, const char *only)
      63             : {
      64             :         return string_escape_mem(src, isz, dst, osz, ESCAPE_ANY_NP, only);
      65             : }
      66             : 
      67       10890 : static inline int string_escape_str(const char *src, char *dst, size_t sz,
      68             :                 unsigned int flags, const char *only)
      69             : {
      70       10890 :         return string_escape_mem(src, strlen(src), dst, sz, flags, only);
      71             : }
      72             : 
      73             : static inline int string_escape_str_any_np(const char *src, char *dst,
      74             :                 size_t sz, const char *only)
      75             : {
      76             :         return string_escape_str(src, dst, sz, ESCAPE_ANY_NP, only);
      77             : }
      78             : 
      79             : static inline void string_upper(char *dst, const char *src)
      80             : {
      81             :         do {
      82             :                 *dst++ = toupper(*src);
      83             :         } while (*src++);
      84             : }
      85             : 
      86             : static inline void string_lower(char *dst, const char *src)
      87             : {
      88             :         do {
      89             :                 *dst++ = tolower(*src);
      90             :         } while (*src++);
      91             : }
      92             : 
      93             : char *kstrdup_quotable(const char *src, gfp_t gfp);
      94             : char *kstrdup_quotable_cmdline(struct task_struct *task, gfp_t gfp);
      95             : char *kstrdup_quotable_file(struct file *file, gfp_t gfp);
      96             : 
      97             : void kfree_strarray(char **array, size_t n);
      98             : 
      99             : #endif