source3/registry/reg_parse_internal.c

   1 /* * Samba Unix/Linux SMB client library
   2  *
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation; either version 3 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15  */
  16 /**
  17  * @file   reg_parse_internal.h
  18  * @author Gregor Beck <gb@sernet.de>
  19  * @date   Sep 2010
  20  * @brief
  21  */
  22
  23 #include "reg_parse_internal.h"
  24 #include "cbuf.h"
  25 #include "srprs.h"
  26 #include "registry.h"
  27
  28 size_t iconvert_talloc(const void* ctx,
  29                        smb_iconv_t cd,
  30                        const char* src, size_t srclen,
  31                        char** pdst)
  32 {
  33         size_t dstlen, ret;
  34         size_t obytes, ibytes;
  35         char *optr, *dst, *tmp;
  36         const char* iptr;
  37
  38         if (cd == NULL || cd == ((smb_iconv_t)-1)) {
  39                 return -1;
  40         }
  41
  42         dst = *pdst;
  43
  44         if (dst == NULL) {
  45                 /* dstlen = 2*srclen + 2; */
  46                 dstlen = srclen;
  47                 dst = talloc_size(ctx, dstlen);
  48                 if (dst == NULL) {
  49                         DEBUG(0,("iconver_talloc no mem\n"));
  50                         return -1;
  51                 }
  52         } else {
  53                 dstlen = talloc_get_size(dst);
  54         }
  55 convert:
  56         iptr   = src;
  57         ibytes = srclen;
  58         optr   = dst;
  59         obytes = dstlen-2;
  60
  61         ret = smb_iconv(cd, &iptr, &ibytes, &optr, &obytes);
  62
  63         if(ret == -1) {
  64                 const char *reason="unknown error";
  65                 switch(errno) {
  66                 case EINVAL:
  67                         reason="Incomplete multibyte sequence";
  68                         break;
  69                 case E2BIG:
  70                         dstlen = 2*dstlen + 2;
  71                         tmp    = talloc_realloc(ctx, dst, char, dstlen);
  72                         if (tmp == NULL) {
  73                                 reason="talloc_realloc failed";
  74                                 break;
  75                         }
  76                         dst = tmp;
  77                         goto convert;
  78                 case EILSEQ:
  79                         reason="Illegal multibyte sequence";
  80                         break;
  81                 }
  82                 DEBUG(0,("Conversion error: %s(%.80s) %li\n", reason, iptr, iptr-src));
  83                 talloc_free(dst);
  84                 return -1;
  85         }
  86
  87         dstlen = (dstlen-2) - obytes;
  88
  89         SSVAL(dst, dstlen, 0);
  90
  91         *pdst = dst;
  92         return dstlen;
  93 }
  94
  95 #ifndef HKEY_CURRENT_CONFIG
  96 #define HKEY_CURRENT_CONFIG             0x80000005
  97 #endif
  98 #ifndef HKEY_DYN_DATA
  99 #define HKEY_DYN_DATA                   0x80000006
 100 #endif
 101 #ifndef HKEY_PERFORMANCE_TEXT
 102 #define HKEY_PERFORMANCE_TEXT           0x80000050
 103 #endif
 104 #ifndef HKEY_PERFORMANCE_NLSTEXT
 105 #define HKEY_PERFORMANCE_NLSTEXT        0x80000060
 106 #endif
 107
 108 #define HIVE_INFO_ENTRY(SHORT,LONG)                     \
 109 static const struct hive_info HIVE_INFO_##SHORT = {     \
 110         .handle = LONG,                                 \
 111         .short_name = #SHORT,                           \
 112         .short_name_len = sizeof(#SHORT)-1,             \
 113         .long_name = #LONG,                             \
 114         .long_name_len = sizeof(#LONG)-1,               \
 115 }
 116
 117 HIVE_INFO_ENTRY(HKLM, HKEY_LOCAL_MACHINE);
 118 HIVE_INFO_ENTRY(HKCU, HKEY_CURRENT_USER);
 119 HIVE_INFO_ENTRY(HKCR, HKEY_CLASSES_ROOT);
 120 HIVE_INFO_ENTRY(HKU , HKEY_USERS);
 121 HIVE_INFO_ENTRY(HKCC, HKEY_CURRENT_CONFIG);
 122 HIVE_INFO_ENTRY(HKDD, HKEY_DYN_DATA);
 123 HIVE_INFO_ENTRY(HKPD, HKEY_PERFORMANCE_DATA);
 124 HIVE_INFO_ENTRY(HKPT, HKEY_PERFORMANCE_TEXT);
 125 HIVE_INFO_ENTRY(HKPN, HKEY_PERFORMANCE_NLSTEXT);
 126 #undef HIVE_INFO_ENTRY
 127
 128 static const struct hive_info* HIVE_INFO[] = {
 129         &HIVE_INFO_HKLM, &HIVE_INFO_HKCU, &HIVE_INFO_HKCR, &HIVE_INFO_HKU,
 130         &HIVE_INFO_HKCC, &HIVE_INFO_HKDD, &HIVE_INFO_HKPD, &HIVE_INFO_HKPT,
 131         &HIVE_INFO_HKPN, NULL
 132 };
 133
 134 const struct hive_info* hive_info(const char* name, int nlen)
 135 {
 136         const struct hive_info** info;
 137         char buf[32];
 138         int s;
 139
 140         if (nlen >= sizeof(buf)) {
 141                 return NULL;
 142         }
 143         for (s=0; s<nlen; s++) {
 144                 buf[s] = toupper(name[s]);
 145         }
 146         buf[s] = '\0';
 147
 148         if ((s < 3) || (strncmp(buf, "HK", 2) != 0)) {
 149                 return NULL;
 150         }
 151
 152         if (s <= 4) {
 153                 for(info = HIVE_INFO; *info; info++) {
 154                         if (strcmp(buf+2, (*info)->short_name+2) == 0) {
 155                                 return *info;
 156                         }
 157                 }
 158                 return NULL;
 159         }
 160
 161         if ((s < 10) || (strncmp(buf, "HKEY_", 5)) != 0) {
 162                 return NULL;
 163         }
 164
 165         for(info = HIVE_INFO; *info; info++) {
 166                 if (strcmp(buf+5, (*info)->long_name+5) == 0) {
 167                         return *info;
 168                 }
 169         }
 170         return NULL;
 171 }
 172
 173 const char* get_charset(const char* c)
 174 {
 175         if (strcmp(c, "dos") == 0) {
 176                 return lp_dos_charset();
 177         } else if (strcmp(c, "unix") == 0) {
 178                 return lp_unix_charset();
 179         } else {
 180                 return c;
 181         }
 182 }
 183
 184 bool set_iconv(smb_iconv_t* t, const char* to, const char* from)
 185 {
 186         smb_iconv_t cd = (smb_iconv_t)-1;
 187
 188         if (to && from) {
 189                 to   = get_charset(to);
 190                 from = get_charset(from);
 191                 cd   = smb_iconv_open(to, from);
 192                 if (cd == ((smb_iconv_t)-1)) {
 193                         return false;
 194                 }
 195         }
 196         if ((*t != (smb_iconv_t)NULL) && (*t != (smb_iconv_t)-1)) {
 197                 smb_iconv_close(*t);
 198         }
 199         *t = cd;
 200         return true;
 201 }
 202
 203 /**
 204  * Parse option string
 205  * @param[in,out] ptr parse position
 206  * @param[in] mem_ctx talloc context
 207  * @param[out] name ptr 2 value
 208  * @param[out] value ptr 2 value
 209  * @return true on success
 210  */
 211 bool srprs_option(const char** ptr, const void* mem_ctx, char** name, char** value)
 212 {
 213         const char* pos = *ptr;
 214         void* ctx = talloc_new(mem_ctx);
 215
 216         cbuf* key = cbuf_new(ctx);
 217         cbuf* val = NULL;
 218
 219         while(srprs_charsetinv(&pos, ",= \t\n\r", key))
 220                 ;
 221         if (pos == *ptr) {
 222                 talloc_free(ctx);
 223                 return false;
 224         }
 225
 226         if (name != NULL) {
 227                 *name = talloc_steal(mem_ctx, cbuf_gets(key, 0));
 228         }
 229
 230         if (*pos == '=') {
 231                 val = cbuf_new(ctx);
 232                 pos++;
 233                 if (!srprs_quoted_string(ptr, val, NULL)) {
 234                         while(srprs_charsetinv(&pos, ", \t\n\r", val))
 235                                 ;
 236                 }
 237                 if (value != NULL) {
 238                         *value = talloc_steal(mem_ctx, cbuf_gets(val, 0));
 239                 }
 240         } else {
 241                 if (value != NULL) {
 242                         *value = NULL;
 243                 }
 244         }
 245
 246         while(srprs_char(&pos, ','))
 247                 ;
 248
 249         *ptr = pos;
 250         return true;
 251 }
 252
 253 #define CH_INVALID ((charset_t)-1)
 254 static const struct {
 255         const char* const name;
 256         charset_t ctype;
 257         int  len;
 258         char seq[4];
 259 } BOM[] = {
 260         {"UTF-8",    CH_UTF8,    3, {0xEF, 0xBB, 0xBF}},
 261         {"UTF-32LE", CH_INVALID, 4, {0xFF, 0xFE, 0x00, 0x00}},
 262         {"UTF-16LE", CH_UTF16LE, 2, {0xFF, 0xFE}},
 263         {"UTF-16BE", CH_UTF16BE, 2, {0xFE, 0xFF}},
 264         {"UTF-32BE", CH_INVALID, 4, {0x00, 0x00, 0xFE, 0xFF}},
 265         {NULL,       CH_INVALID, 0, {}}
 266 };
 267
 268 bool srprs_bom(const char** ptr, const char** name, charset_t* ctype)
 269 {
 270         int i;
 271         for (i=0; BOM[i].name; i++) {
 272                 if (memcmp(*ptr, BOM[i].seq, BOM[i].len) == 0) {
 273                         break;
 274                 }
 275         }
 276
 277         if (BOM[i].name != NULL) {
 278                 DEBUG(0, ("Found Byte Order Mark for : %s\n", BOM[i].name));
 279
 280                 if (name != NULL) {
 281                         *name  = BOM[i].name;
 282                 }
 283
 284                 if (ctype != NULL) {
 285                         *ctype = BOM[i].ctype;
 286                 }
 287
 288                 *ptr  += BOM[i].len;
 289
 290                 return true;
 291         }
 292         return false;
 293 }
 294
 295 int write_bom(FILE* file, const char* charset, charset_t ctype)
 296 {
 297         int i;
 298         if ( charset == NULL ) {
 299                 for (i=0; BOM[i].name; i++) {
 300                         if (BOM[i].ctype == ctype) {
 301                                 return fwrite(BOM[i].seq, 1, BOM[i].len, file);
 302                         }
 303                 }
 304                 DEBUG(0, ("No Byte Order Mark for charset_t: %u\n", (unsigned)ctype));
 305         } else {
 306                 for (i=0; BOM[i].name; i++) {
 307                         if (StrCaseCmp(BOM[i].name, charset) == 0) {
 308                                 return fwrite(BOM[i].seq, 1, BOM[i].len, file);
 309                         }
 310                 }
 311                 DEBUG(0, ("No Byte Order Mark for charset_t: %s\n", charset));
 312         }
 313         return 0;
 314 }
 315
 316
 317 int cbuf_puts_case(cbuf* s, const char* str, size_t len, enum fmt_case fmt)
 318 {
 319         size_t pos = cbuf_getpos(s);
 320         int ret = cbuf_puts(s, str, len);
 321         char* ptr = cbuf_gets(s,pos);
 322
 323         if (ret <= 0) {
 324                 return ret;
 325         }
 326
 327         switch (fmt) {
 328         case FMT_CASE_PRESERVE:
 329                 break;
 330         case FMT_CASE_UPPER:
 331                 while(*ptr != '\0') {
 332                         *ptr = toupper(*ptr);
 333                         ptr++;
 334                 }
 335                 break;
 336         case FMT_CASE_TITLE:
 337                 *ptr = toupper(*ptr);
 338                 ptr++;
 339         case FMT_CASE_LOWER:
 340                 while(*ptr != '\0') {
 341                         *ptr = tolower(*ptr);
 342                         ptr++;
 343                 }
 344         }
 345         return ret;
 346 }