contrib/putty/UNIX/UXSTORE.C

   1 /*\r
   2  * uxstore.c: Unix-specific implementation of the interface defined\r
   3  * in storage.h.\r
   4  */\r
   5 \r
   6 #include <stdio.h>\r
   7 #include <stdlib.h>\r
   8 #include <string.h>\r
   9 #include <assert.h>\r
  10 #include <errno.h>\r
  11 #include <ctype.h>\r
  12 #include <limits.h>\r
  13 #include <unistd.h>\r
  14 #include <fcntl.h>\r
  15 #include <dirent.h>\r
  16 #include <sys/stat.h>\r
  17 #include <sys/types.h>\r
  18 #include <pwd.h>\r
  19 #include "putty.h"\r
  20 #include "storage.h"\r
  21 #include "tree234.h"\r
  22 \r
  23 #ifdef PATH_MAX\r
  24 #define FNLEN PATH_MAX\r
  25 #else\r
  26 #define FNLEN 1024 /* XXX */\r
  27 #endif\r
  28 \r
  29 enum {\r
  30     INDEX_DIR, INDEX_HOSTKEYS, INDEX_HOSTKEYS_TMP, INDEX_RANDSEED,\r
  31     INDEX_SESSIONDIR, INDEX_SESSION,\r
  32 };\r
  33 \r
  34 static const char hex[16] = "0123456789ABCDEF";\r
  35 \r
  36 static char *mungestr(const char *in)\r
  37 {\r
  38     char *out, *ret;\r
  39 \r
  40     if (!in || !*in)\r
  41         in = "Default Settings";\r
  42 \r
  43     ret = out = snewn(3*strlen(in)+1, char);\r
  44 \r
  45     while (*in) {\r
  46         /*\r
  47          * There are remarkably few punctuation characters that\r
  48          * aren't shell-special in some way or likely to be used as\r
  49          * separators in some file format or another! Hence we use\r
  50          * opt-in for safe characters rather than opt-out for\r
  51          * specific unsafe ones...\r
  52          */\r
  53         if (*in!='+' && *in!='-' && *in!='.' && *in!='@' && *in!='_' &&\r
  54             !(*in >= '0' && *in <= '9') &&\r
  55             !(*in >= 'A' && *in <= 'Z') &&\r
  56             !(*in >= 'a' && *in <= 'z')) {\r
  57             *out++ = '%';\r
  58             *out++ = hex[((unsigned char) *in) >> 4];\r
  59             *out++ = hex[((unsigned char) *in) & 15];\r
  60         } else\r
  61             *out++ = *in;\r
  62         in++;\r
  63     }\r
  64     *out = '\0';\r
  65     return ret;\r
  66 }\r
  67 \r
  68 static char *unmungestr(const char *in)\r
  69 {\r
  70     char *out, *ret;\r
  71     out = ret = snewn(strlen(in)+1, char);\r
  72     while (*in) {\r
  73         if (*in == '%' && in[1] && in[2]) {\r
  74             int i, j;\r
  75 \r
  76             i = in[1] - '0';\r
  77             i -= (i > 9 ? 7 : 0);\r
  78             j = in[2] - '0';\r
  79             j -= (j > 9 ? 7 : 0);\r
  80 \r
  81             *out++ = (i << 4) + j;\r
  82             in += 3;\r
  83         } else {\r
  84             *out++ = *in++;\r
  85         }\r
  86     }\r
  87     *out = '\0';\r
  88     return ret;\r
  89 }\r
  90 \r
  91 static char *make_filename(int index, const char *subname)\r
  92 {\r
  93     char *env, *tmp, *ret;\r
  94 \r
  95     /*\r
  96      * Allow override of the PuTTY configuration location, and of\r
  97      * specific subparts of it, by means of environment variables.\r
  98      */\r
  99     if (index == INDEX_DIR) {\r
 100         struct passwd *pwd;\r
 101 \r
 102         env = getenv("PUTTYDIR");\r
 103         if (env)\r
 104             return dupstr(env);\r
 105         env = getenv("HOME");\r
 106         if (env)\r
 107             return dupprintf("%s/.putty", env);\r
 108         pwd = getpwuid(getuid());\r
 109         if (pwd && pwd->pw_dir)\r
 110             return dupprintf("%s/.putty", pwd->pw_dir);\r
 111         return dupstr("/.putty");\r
 112     }\r
 113     if (index == INDEX_SESSIONDIR) {\r
 114         env = getenv("PUTTYSESSIONS");\r
 115         if (env)\r
 116             return dupstr(env);\r
 117         tmp = make_filename(INDEX_DIR, NULL);\r
 118         ret = dupprintf("%s/sessions", tmp);\r
 119         sfree(tmp);\r
 120         return ret;\r
 121     }\r
 122     if (index == INDEX_SESSION) {\r
 123         char *munged = mungestr(subname);\r
 124         tmp = make_filename(INDEX_SESSIONDIR, NULL);\r
 125         ret = dupprintf("%s/%s", tmp, munged);\r
 126         sfree(tmp);\r
 127         sfree(munged);\r
 128         return ret;\r
 129     }\r
 130     if (index == INDEX_HOSTKEYS) {\r
 131         env = getenv("PUTTYSSHHOSTKEYS");\r
 132         if (env)\r
 133             return dupstr(env);\r
 134         tmp = make_filename(INDEX_DIR, NULL);\r
 135         ret = dupprintf("%s/sshhostkeys", tmp);\r
 136         sfree(tmp);\r
 137         return ret;\r
 138     }\r
 139     if (index == INDEX_HOSTKEYS_TMP) {\r
 140         tmp = make_filename(INDEX_HOSTKEYS, NULL);\r
 141         ret = dupprintf("%s.tmp", tmp);\r
 142         sfree(tmp);\r
 143         return ret;\r
 144     }\r
 145     if (index == INDEX_RANDSEED) {\r
 146         env = getenv("PUTTYRANDOMSEED");\r
 147         if (env)\r
 148             return dupstr(env);\r
 149         tmp = make_filename(INDEX_DIR, NULL);\r
 150         ret = dupprintf("%s/randomseed", tmp);\r
 151         sfree(tmp);\r
 152         return ret;\r
 153     }\r
 154     tmp = make_filename(INDEX_DIR, NULL);\r
 155     ret = dupprintf("%s/ERROR", tmp);\r
 156     sfree(tmp);\r
 157     return ret;\r
 158 }\r
 159 \r
 160 void *open_settings_w(const char *sessionname, char **errmsg)\r
 161 {\r
 162     char *filename;\r
 163     FILE *fp;\r
 164 \r
 165     *errmsg = NULL;\r
 166 \r
 167     /*\r
 168      * Start by making sure the .putty directory and its sessions\r
 169      * subdir actually exist. Ignore error returns from mkdir since\r
 170      * they're perfectly likely to be `already exists', and any\r
 171      * other error will trip us up later on so there's no real need\r
 172      * to catch it now.\r
 173      */\r
 174     filename = make_filename(INDEX_SESSIONDIR, NULL);\r
 175     if (mkdir(filename, 0700) != 0) {\r
 176         char *filename2 = make_filename(INDEX_DIR, NULL);\r
 177         mkdir(filename2, 0700);\r
 178         sfree(filename2);\r
 179         mkdir(filename, 0700);\r
 180     }\r
 181     sfree(filename);\r
 182 \r
 183     filename = make_filename(INDEX_SESSION, sessionname);\r
 184     fp = fopen(filename, "w");\r
 185     if (!fp) {\r
 186         *errmsg = dupprintf("Unable to create %s: %s",\r
 187                             filename, strerror(errno));\r
 188         sfree(filename);\r
 189         return NULL;                   /* can't open */\r
 190     }\r
 191     sfree(filename);\r
 192     return fp;\r
 193 }\r
 194 \r
 195 void write_setting_s(void *handle, const char *key, const char *value)\r
 196 {\r
 197     FILE *fp = (FILE *)handle;\r
 198     fprintf(fp, "%s=%s\n", key, value);\r
 199 }\r
 200 \r
 201 void write_setting_i(void *handle, const char *key, int value)\r
 202 {\r
 203     FILE *fp = (FILE *)handle;\r
 204     fprintf(fp, "%s=%d\n", key, value);\r
 205 }\r
 206 \r
 207 void close_settings_w(void *handle)\r
 208 {\r
 209     FILE *fp = (FILE *)handle;\r
 210     fclose(fp);\r
 211 }\r
 212 \r
 213 /*\r
 214  * Reading settings, for the moment, is done by retrieving X\r
 215  * resources from the X display. When we introduce disk files, I\r
 216  * think what will happen is that the X resources will override\r
 217  * PuTTY's inbuilt defaults, but that the disk files will then\r
 218  * override those. This isn't optimal, but it's the best I can\r
 219  * immediately work out.\r
 220  * FIXME: the above comment is a bit out of date. Did it happen?\r
 221  */\r
 222 \r
 223 struct skeyval {\r
 224     const char *key;\r
 225     const char *value;\r
 226 };\r
 227 \r
 228 static tree234 *xrmtree = NULL;\r
 229 \r
 230 int keycmp(void *av, void *bv)\r
 231 {\r
 232     struct skeyval *a = (struct skeyval *)av;\r
 233     struct skeyval *b = (struct skeyval *)bv;\r
 234     return strcmp(a->key, b->key);\r
 235 }\r
 236 \r
 237 void provide_xrm_string(char *string)\r
 238 {\r
 239     char *p, *q, *key;\r
 240     struct skeyval *xrms, *ret;\r
 241 \r
 242     p = q = strchr(string, ':');\r
 243     if (!q) {\r
 244         fprintf(stderr, "pterm: expected a colon in resource string"\r
 245                 " \"%s\"\n", string);\r
 246         return;\r
 247     }\r
 248     q++;\r
 249     while (p > string && p[-1] != '.' && p[-1] != '*')\r
 250         p--;\r
 251     xrms = snew(struct skeyval);\r
 252     key = snewn(q-p, char);\r
 253     memcpy(key, p, q-p);\r
 254     key[q-p-1] = '\0';\r
 255     xrms->key = key;\r
 256     while (*q && isspace((unsigned char)*q))\r
 257         q++;\r
 258     xrms->value = dupstr(q);\r
 259 \r
 260     if (!xrmtree)\r
 261         xrmtree = newtree234(keycmp);\r
 262 \r
 263     ret = add234(xrmtree, xrms);\r
 264     if (ret) {\r
 265         /* Override an existing string. */\r
 266         del234(xrmtree, ret);\r
 267         add234(xrmtree, xrms);\r
 268     }\r
 269 }\r
 270 \r
 271 const char *get_setting(const char *key)\r
 272 {\r
 273     struct skeyval tmp, *ret;\r
 274     tmp.key = key;\r
 275     if (xrmtree) {\r
 276         ret = find234(xrmtree, &tmp, NULL);\r
 277         if (ret)\r
 278             return ret->value;\r
 279     }\r
 280     return x_get_default(key);\r
 281 }\r
 282 \r
 283 void *open_settings_r(const char *sessionname)\r
 284 {\r
 285     char *filename;\r
 286     FILE *fp;\r
 287     char *line;\r
 288     tree234 *ret;\r
 289 \r
 290     filename = make_filename(INDEX_SESSION, sessionname);\r
 291     fp = fopen(filename, "r");\r
 292     sfree(filename);\r
 293     if (!fp)\r
 294         return NULL;                   /* can't open */\r
 295 \r
 296     ret = newtree234(keycmp);\r
 297 \r
 298     while ( (line = fgetline(fp)) ) {\r
 299         char *value = strchr(line, '=');\r
 300         struct skeyval *kv;\r
 301 \r
 302         if (!value)\r
 303             continue;\r
 304         *value++ = '\0';\r
 305         value[strcspn(value, "\r\n")] = '\0';   /* trim trailing NL */\r
 306 \r
 307         kv = snew(struct skeyval);\r
 308         kv->key = dupstr(line);\r
 309         kv->value = dupstr(value);\r
 310         add234(ret, kv);\r
 311 \r
 312         sfree(line);\r
 313     }\r
 314 \r
 315     fclose(fp);\r
 316 \r
 317     return ret;\r
 318 }\r
 319 \r
 320 char *read_setting_s(void *handle, const char *key, char *buffer, int buflen)\r
 321 {\r
 322     tree234 *tree = (tree234 *)handle;\r
 323     const char *val;\r
 324     struct skeyval tmp, *kv;\r
 325 \r
 326     tmp.key = key;\r
 327     if (tree != NULL &&\r
 328         (kv = find234(tree, &tmp, NULL)) != NULL) {\r
 329         val = kv->value;\r
 330         assert(val != NULL);\r
 331     } else\r
 332         val = get_setting(key);\r
 333 \r
 334     if (!val)\r
 335         return NULL;\r
 336     else {\r
 337         strncpy(buffer, val, buflen);\r
 338         buffer[buflen-1] = '\0';\r
 339         return buffer;\r
 340     }\r
 341 }\r
 342 \r
 343 int read_setting_i(void *handle, const char *key, int defvalue)\r
 344 {\r
 345     tree234 *tree = (tree234 *)handle;\r
 346     const char *val;\r
 347     struct skeyval tmp, *kv;\r
 348 \r
 349     tmp.key = key;\r
 350     if (tree != NULL &&\r
 351         (kv = find234(tree, &tmp, NULL)) != NULL) {\r
 352         val = kv->value;\r
 353         assert(val != NULL);\r
 354     } else\r
 355         val = get_setting(key);\r
 356 \r
 357     if (!val)\r
 358         return defvalue;\r
 359     else\r
 360         return atoi(val);\r
 361 }\r
 362 \r
 363 int read_setting_fontspec(void *handle, const char *name, FontSpec *result)\r
 364 {\r
 365     /*\r
 366      * In GTK1-only PuTTY, we used to store font names simply as a\r
 367      * valid X font description string (logical or alias), under a\r
 368      * bare key such as "Font".\r
 369      * \r
 370      * In GTK2 PuTTY, we have a prefix system where "client:"\r
 371      * indicates a Pango font and "server:" an X one; existing\r
 372      * configuration needs to be reinterpreted as having the\r
 373      * "server:" prefix, so we change the storage key from the\r
 374      * provided name string (e.g. "Font") to a suffixed one\r
 375      * ("FontName").\r
 376      */\r
 377     char *suffname = dupcat(name, "Name", NULL);\r
 378     if (read_setting_s(handle, suffname, result->name, sizeof(result->name))) {\r
 379         sfree(suffname);\r
 380         return TRUE;                   /* got new-style name */\r
 381     }\r
 382     sfree(suffname);\r
 383 \r
 384     /* Fall back to old-style name. */\r
 385     memcpy(result->name, "server:", 7);\r
 386     if (!read_setting_s(handle, name,\r
 387                         result->name + 7, sizeof(result->name) - 7) ||\r
 388         !result->name[7]) {\r
 389         result->name[0] = '\0';\r
 390         return FALSE;\r
 391     } else {\r
 392         return TRUE;\r
 393     }\r
 394 }\r
 395 int read_setting_filename(void *handle, const char *name, Filename *result)\r
 396 {\r
 397     return !!read_setting_s(handle, name, result->path, sizeof(result->path));\r
 398 }\r
 399 \r
 400 void write_setting_fontspec(void *handle, const char *name, FontSpec result)\r
 401 {\r
 402     /*\r
 403      * read_setting_fontspec had to handle two cases, but when\r
 404      * writing our settings back out we simply always generate the\r
 405      * new-style name.\r
 406      */\r
 407     char *suffname = dupcat(name, "Name", NULL);\r
 408     write_setting_s(handle, suffname, result.name);\r
 409     sfree(suffname);\r
 410 }\r
 411 void write_setting_filename(void *handle, const char *name, Filename result)\r
 412 {\r
 413     write_setting_s(handle, name, result.path);\r
 414 }\r
 415 \r
 416 void close_settings_r(void *handle)\r
 417 {\r
 418     tree234 *tree = (tree234 *)handle;\r
 419     struct skeyval *kv;\r
 420 \r
 421     if (!tree)\r
 422         return;\r
 423 \r
 424     while ( (kv = index234(tree, 0)) != NULL) {\r
 425         del234(tree, kv);\r
 426         sfree((char *)kv->key);\r
 427         sfree((char *)kv->value);\r
 428         sfree(kv);\r
 429     }\r
 430 \r
 431     freetree234(tree);\r
 432 }\r
 433 \r
 434 void del_settings(const char *sessionname)\r
 435 {\r
 436     char *filename;\r
 437     filename = make_filename(INDEX_SESSION, sessionname);\r
 438     unlink(filename);\r
 439     sfree(filename);\r
 440 }\r
 441 \r
 442 void *enum_settings_start(void)\r
 443 {\r
 444     DIR *dp;\r
 445     char *filename;\r
 446 \r
 447     filename = make_filename(INDEX_SESSIONDIR, NULL);\r
 448     dp = opendir(filename);\r
 449     sfree(filename);\r
 450 \r
 451     return dp;\r
 452 }\r
 453 \r
 454 char *enum_settings_next(void *handle, char *buffer, int buflen)\r
 455 {\r
 456     DIR *dp = (DIR *)handle;\r
 457     struct dirent *de;\r
 458     struct stat st;\r
 459     char *fullpath;\r
 460     int maxlen, thislen, len;\r
 461     char *unmunged;\r
 462 \r
 463     fullpath = make_filename(INDEX_SESSIONDIR, NULL);\r
 464     maxlen = len = strlen(fullpath);\r
 465 \r
 466     while ( (de = readdir(dp)) != NULL ) {\r
 467         thislen = len + 1 + strlen(de->d_name);\r
 468         if (maxlen < thislen) {\r
 469             maxlen = thislen;\r
 470             fullpath = sresize(fullpath, maxlen+1, char);\r
 471         }\r
 472         fullpath[len] = '/';\r
 473         strncpy(fullpath+len+1, de->d_name, thislen - (len+1));\r
 474         fullpath[thislen] = '\0';\r
 475 \r
 476         if (stat(fullpath, &st) < 0 || !S_ISREG(st.st_mode))\r
 477             continue;                  /* try another one */\r
 478 \r
 479         unmunged = unmungestr(de->d_name);\r
 480         strncpy(buffer, unmunged, buflen);\r
 481         buffer[buflen-1] = '\0';\r
 482         sfree(unmunged);\r
 483         sfree(fullpath);\r
 484         return buffer;\r
 485     }\r
 486 \r
 487     sfree(fullpath);\r
 488     return NULL;\r
 489 }\r
 490 \r
 491 void enum_settings_finish(void *handle)\r
 492 {\r
 493     DIR *dp = (DIR *)handle;\r
 494     closedir(dp);\r
 495 }\r
 496 \r
 497 /*\r
 498  * Lines in the host keys file are of the form\r
 499  * \r
 500  *   type@port:hostname keydata\r
 501  * \r
 502  * e.g.\r
 503  * \r
 504  *   rsa@22:foovax.example.org 0x23,0x293487364395345345....2343\r
 505  */\r
 506 int verify_host_key(const char *hostname, int port,\r
 507                     const char *keytype, const char *key)\r
 508 {\r
 509     FILE *fp;\r
 510     char *filename;\r
 511     char *line;\r
 512     int ret;\r
 513 \r
 514     filename = make_filename(INDEX_HOSTKEYS, NULL);\r
 515     fp = fopen(filename, "r");\r
 516     sfree(filename);\r
 517     if (!fp)\r
 518         return 1;                      /* key does not exist */\r
 519 \r
 520     ret = 1;\r
 521     while ( (line = fgetline(fp)) ) {\r
 522         int i;\r
 523         char *p = line;\r
 524         char porttext[20];\r
 525 \r
 526         line[strcspn(line, "\n")] = '\0';   /* strip trailing newline */\r
 527 \r
 528         i = strlen(keytype);\r
 529         if (strncmp(p, keytype, i))\r
 530             goto done;\r
 531         p += i;\r
 532 \r
 533         if (*p != '@')\r
 534             goto done;\r
 535         p++;\r
 536 \r
 537         sprintf(porttext, "%d", port);\r
 538         i = strlen(porttext);\r
 539         if (strncmp(p, porttext, i))\r
 540             goto done;\r
 541         p += i;\r
 542 \r
 543         if (*p != ':')\r
 544             goto done;\r
 545         p++;\r
 546 \r
 547         i = strlen(hostname);\r
 548         if (strncmp(p, hostname, i))\r
 549             goto done;\r
 550         p += i;\r
 551 \r
 552         if (*p != ' ')\r
 553             goto done;\r
 554         p++;\r
 555 \r
 556         /*\r
 557          * Found the key. Now just work out whether it's the right\r
 558          * one or not.\r
 559          */\r
 560         if (!strcmp(p, key))\r
 561             ret = 0;                   /* key matched OK */\r
 562         else\r
 563             ret = 2;                   /* key mismatch */\r
 564 \r
 565         done:\r
 566         sfree(line);\r
 567         if (ret != 1)\r
 568             break;\r
 569     }\r
 570 \r
 571     fclose(fp);\r
 572     return ret;\r
 573 }\r
 574 \r
 575 void store_host_key(const char *hostname, int port,\r
 576                     const char *keytype, const char *key)\r
 577 {\r
 578     FILE *rfp, *wfp;\r
 579     char *newtext, *line;\r
 580     int headerlen;\r
 581     char *filename, *tmpfilename;\r
 582 \r
 583     newtext = dupprintf("%s@%d:%s %s\n", keytype, port, hostname, key);\r
 584     headerlen = 1 + strcspn(newtext, " ");   /* count the space too */\r
 585 \r
 586     /*\r
 587      * Open both the old file and a new file.\r
 588      */\r
 589     tmpfilename = make_filename(INDEX_HOSTKEYS_TMP, NULL);\r
 590     wfp = fopen(tmpfilename, "w");\r
 591     if (!wfp) {\r
 592         char *dir;\r
 593 \r
 594         dir = make_filename(INDEX_DIR, NULL);\r
 595         mkdir(dir, 0700);\r
 596         sfree(dir);\r
 597 \r
 598         wfp = fopen(tmpfilename, "w");\r
 599     }\r
 600     if (!wfp) {\r
 601         sfree(tmpfilename);\r
 602         return;\r
 603     }\r
 604     filename = make_filename(INDEX_HOSTKEYS, NULL);\r
 605     rfp = fopen(filename, "r");\r
 606 \r
 607     /*\r
 608      * Copy all lines from the old file to the new one that _don't_\r
 609      * involve the same host key identifier as the one we're adding.\r
 610      */\r
 611     if (rfp) {\r
 612         while ( (line = fgetline(rfp)) ) {\r
 613             if (strncmp(line, newtext, headerlen))\r
 614                 fputs(line, wfp);\r
 615         }\r
 616         fclose(rfp);\r
 617     }\r
 618 \r
 619     /*\r
 620      * Now add the new line at the end.\r
 621      */\r
 622     fputs(newtext, wfp);\r
 623 \r
 624     fclose(wfp);\r
 625 \r
 626     rename(tmpfilename, filename);\r
 627 \r
 628     sfree(tmpfilename);\r
 629     sfree(filename);\r
 630     sfree(newtext);\r
 631 }\r
 632 \r
 633 void read_random_seed(noise_consumer_t consumer)\r
 634 {\r
 635     int fd;\r
 636     char *fname;\r
 637 \r
 638     fname = make_filename(INDEX_RANDSEED, NULL);\r
 639     fd = open(fname, O_RDONLY);\r
 640     sfree(fname);\r
 641     if (fd >= 0) {\r
 642         char buf[512];\r
 643         int ret;\r
 644         while ( (ret = read(fd, buf, sizeof(buf))) > 0)\r
 645             consumer(buf, ret);\r
 646         close(fd);\r
 647     }\r
 648 }\r
 649 \r
 650 void write_random_seed(void *data, int len)\r
 651 {\r
 652     int fd;\r
 653     char *fname;\r
 654 \r
 655     fname = make_filename(INDEX_RANDSEED, NULL);\r
 656     /*\r
 657      * Don't truncate the random seed file if it already exists; if\r
 658      * something goes wrong half way through writing it, it would\r
 659      * be better to leave the old data there than to leave it empty.\r
 660      */\r
 661     fd = open(fname, O_CREAT | O_WRONLY, 0600);\r
 662     if (fd < 0) {\r
 663         char *dir;\r
 664 \r
 665         dir = make_filename(INDEX_DIR, NULL);\r
 666         mkdir(dir, 0700);\r
 667         sfree(dir);\r
 668 \r
 669         fd = open(fname, O_CREAT | O_WRONLY, 0600);\r
 670     }\r
 671 \r
 672     while (len > 0) {\r
 673         int ret = write(fd, data, len);\r
 674         if (ret <= 0) break;\r
 675         len -= ret;\r
 676         data = (char *)data + len;\r
 677     }\r
 678 \r
 679     close(fd);\r
 680     sfree(fname);\r
 681 }\r
 682 \r
 683 void cleanup_all(void)\r
 684 {\r
 685 }\r