source3/lib/string_replace.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  *
   4  * Copyright (C) Volker Lendecke, 2005
   5  * Copyright (C) Aravind Srinivasan, 2009
   6  * Copyright (C) Guenter Kukkukk, 2013
   7  * Copyright (C) Ralph Boehme, 2017
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 3 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23 #include "includes.h"
  24 #include "smbd/smbd.h"
  25 #include "string_replace.h"
  26
  27 #define MAP_SIZE        0xFF
  28 #define MAP_NUM         0x101 /* max unicode charval / MAP_SIZE */
  29 #define T_OFFSET(_v_)   ((_v_ % MAP_SIZE))
  30 #define T_START(_v_)    (((_v_ / MAP_SIZE) * MAP_SIZE))
  31 #define T_PICK(_v_)     ((_v_ / MAP_SIZE))
  32
  33 struct char_mappings {
  34         smb_ucs2_t entry[MAP_SIZE][2];
  35 };
  36
  37 static bool build_table(struct char_mappings **cmaps, int value)
  38 {
  39         int i;
  40         int start = T_START(value);
  41
  42         (*cmaps) = talloc_zero(NULL, struct char_mappings);
  43
  44         if (!*cmaps)
  45                 return False;
  46
  47         for (i = 0; i < MAP_SIZE;i++) {
  48                 (*cmaps)->entry[i][vfs_translate_to_unix] = start + i;
  49                 (*cmaps)->entry[i][vfs_translate_to_windows] = start + i;
  50         }
  51
  52         return True;
  53 }
  54
  55 static void set_tables(struct char_mappings **cmaps,
  56                        long unix_map,
  57                        long windows_map)
  58 {
  59         int i;
  60
  61         /* set unix -> windows */
  62         i = T_OFFSET(unix_map);
  63         cmaps[T_PICK(unix_map)]->entry[i][vfs_translate_to_windows] = windows_map;
  64
  65         /* set windows -> unix */
  66         i = T_OFFSET(windows_map);
  67         cmaps[T_PICK(windows_map)]->entry[i][vfs_translate_to_unix] = unix_map;
  68 }
  69
  70 static bool build_ranges(struct char_mappings **cmaps,
  71                          long unix_map,
  72                          long windows_map)
  73 {
  74
  75         if (!cmaps[T_PICK(unix_map)]) {
  76                 if (!build_table(&cmaps[T_PICK(unix_map)], unix_map))
  77                         return False;
  78         }
  79
  80         if (!cmaps[T_PICK(windows_map)]) {
  81                 if (!build_table(&cmaps[T_PICK(windows_map)], windows_map))
  82                         return False;
  83         }
  84
  85         set_tables(cmaps, unix_map, windows_map);
  86
  87         return True;
  88 }
  89
  90 struct char_mappings **string_replace_init_map(TALLOC_CTX *mem_ctx,
  91                                                const char **mappings)
  92 {
  93         int i;
  94         char *tmp;
  95         fstring mapping;
  96         long unix_map, windows_map;
  97         struct char_mappings **cmaps = NULL;
  98
  99         if (mappings == NULL) {
 100                 return NULL;
 101         }
 102
 103         cmaps = TALLOC_ZERO(mem_ctx, MAP_NUM * sizeof(struct char_mappings *));
 104         if (cmaps == NULL) {
 105                 return NULL;
 106         }
 107
 108         /*
 109          * catia mappings are of the form :
 110          * UNIX char (in 0xnn hex) : WINDOWS char (in 0xnn hex)
 111          *
 112          * multiple mappings are comma separated in smb.conf
 113          */
 114
 115         for (i = 0; mappings[i]; i++) {
 116                 fstrcpy(mapping, mappings[i]);
 117                 unix_map = strtol(mapping, &tmp, 16);
 118                 if (unix_map == 0 && errno == EINVAL) {
 119                         DEBUG(0, ("INVALID CATIA MAPPINGS - %s\n", mapping));
 120                         continue;
 121                 }
 122                 windows_map = strtol(++tmp, NULL, 16);
 123                 if (windows_map == 0 && errno == EINVAL) {
 124                         DEBUG(0, ("INVALID CATIA MAPPINGS - %s\n", mapping));
 125                         continue;
 126                 }
 127
 128                 if (!build_ranges(cmaps, unix_map, windows_map)) {
 129                         DEBUG(0, ("TABLE ERROR - CATIA MAPPINGS - %s\n", mapping));
 130                         continue;
 131                 }
 132         }
 133
 134         return cmaps;
 135 }
 136
 137 NTSTATUS string_replace_allocate(connection_struct *conn,
 138                                  const char *name_in,
 139                                  struct char_mappings **cmaps,
 140                                  TALLOC_CTX *mem_ctx,
 141                                  char **mapped_name,
 142                                  enum vfs_translate_direction direction)
 143 {
 144         static smb_ucs2_t *tmpbuf = NULL;
 145         smb_ucs2_t *ptr = NULL;
 146         struct char_mappings *map = NULL;
 147         size_t converted_size;
 148         bool ok;
 149
 150         ok = push_ucs2_talloc(talloc_tos(), &tmpbuf, name_in,
 151                               &converted_size);
 152         if (!ok) {
 153                 return map_nt_error_from_unix(errno);
 154         }
 155
 156         for (ptr = tmpbuf; *ptr; ptr++) {
 157                 if (*ptr == 0) {
 158                         break;
 159                 }
 160                 if (cmaps == NULL) {
 161                         continue;
 162                 }
 163                 map = cmaps[T_PICK((*ptr))];
 164                 if (map == NULL) {
 165                         /* nothing to do */
 166                         continue;
 167                 }
 168
 169                 *ptr = map->entry[T_OFFSET((*ptr))][direction];
 170         }
 171
 172         ok = pull_ucs2_talloc(mem_ctx, mapped_name, tmpbuf,
 173                               &converted_size);
 174         TALLOC_FREE(tmpbuf);
 175         if (!ok) {
 176                 return map_nt_error_from_unix(errno);
 177         }
 178         return NT_STATUS_OK;
 179 }
 180
 181 const char *macos_string_replace_map =
 182         "0x01:0xf001,0x02:0xf002,0x03:0xf003,0x04:0xf004,"
 183         "0x05:0xf005,0x06:0xf006,0x07:0xf007,0x08:0xf008,"
 184         "0x09:0xf009,0x0a:0xf00a,0x0b:0xf00b,0x0c:0xf00c,"
 185         "0x0d:0xf00d,0x0e:0xf00e,0x0f:0xf00f,0x10:0xf010,"
 186         "0x11:0xf011,0x12:0xf012,0x13:0xf013,0x14:0xf014,"
 187         "0x15:0xf015,0x16:0xf016,0x17:0xf017,0x18:0xf018,"
 188         "0x19:0xf019,0x1a:0xf01a,0x1b:0xf01b,0x1c:0xf01c,"
 189         "0x1d:0xf01d,0x1e:0xf01e,0x1f:0xf01f,"
 190         "0x22:0xf020,0x2a:0xf021,0x3a:0xf022,0x3c:0xf023,"
 191         "0x3e:0xf024,0x3f:0xf025,0x5c:0xf026,0x7c:0xf027";