drivers/accessibility/speakup/kobjects.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Speakup kobject implementation
   4  *
   5  * Copyright (C) 2009 William Hubbs
   6  *
   7  * This code is based on kobject-example.c, which came with linux 2.6.x.
   8  *
   9  * Copyright (C) 2004-2007 Greg Kroah-Hartman <greg@kroah.com>
  10  * Copyright (C) 2007 Novell Inc.
  11  *
  12  * Released under the GPL version 2 only.
  13  *
  14  */
  15 #include <linux/slab.h>         /* For kmalloc. */
  16 #include <linux/kernel.h>
  17 #include <linux/kobject.h>
  18 #include <linux/string.h>
  19 #include <linux/string_helpers.h>
  20 #include <linux/sysfs.h>
  21 #include <linux/ctype.h>
  22
  23 #include "speakup.h"
  24 #include "spk_priv.h"
  25
  26 /*
  27  * This is called when a user reads the characters or chartab sys file.
  28  */
  29 static ssize_t chars_chartab_show(struct kobject *kobj,
  30                                   struct kobj_attribute *attr, char *buf)
  31 {
  32         int i;
  33         int len = 0;
  34         char *cp;
  35         char *buf_pointer = buf;
  36         size_t bufsize = PAGE_SIZE;
  37         unsigned long flags;
  38
  39         spin_lock_irqsave(&speakup_info.spinlock, flags);
  40         *buf_pointer = '\0';
  41         for (i = 0; i < 256; i++) {
  42                 if (bufsize <= 1)
  43                         break;
  44                 if (strcmp("characters", attr->attr.name) == 0) {
  45                         len = scnprintf(buf_pointer, bufsize, "%d\t%s\n",
  46                                         i, spk_characters[i]);
  47                 } else {        /* show chartab entry */
  48                         if (IS_TYPE(i, B_CTL))
  49                                 cp = "B_CTL";
  50                         else if (IS_TYPE(i, WDLM))
  51                                 cp = "WDLM";
  52                         else if (IS_TYPE(i, A_PUNC))
  53                                 cp = "A_PUNC";
  54                         else if (IS_TYPE(i, PUNC))
  55                                 cp = "PUNC";
  56                         else if (IS_TYPE(i, NUM))
  57                                 cp = "NUM";
  58                         else if (IS_TYPE(i, A_CAP))
  59                                 cp = "A_CAP";
  60                         else if (IS_TYPE(i, ALPHA))
  61                                 cp = "ALPHA";
  62                         else if (IS_TYPE(i, B_CAPSYM))
  63                                 cp = "B_CAPSYM";
  64                         else if (IS_TYPE(i, B_SYM))
  65                                 cp = "B_SYM";
  66                         else
  67                                 cp = "0";
  68                         len =
  69                             scnprintf(buf_pointer, bufsize, "%d\t%s\n", i, cp);
  70                 }
  71                 bufsize -= len;
  72                 buf_pointer += len;
  73         }
  74         spin_unlock_irqrestore(&speakup_info.spinlock, flags);
  75         return buf_pointer - buf;
  76 }
  77
  78 /*
  79  * Print informational messages or warnings after updating
  80  * character descriptions or chartab entries.
  81  */
  82 static void report_char_chartab_status(int reset, int received, int used,
  83                                        int rejected, int do_characters)
  84 {
  85         static char const *object_type[] = {
  86                 "character class entries",
  87                 "character descriptions",
  88         };
  89         int len;
  90         char buf[80];
  91
  92         if (reset) {
  93                 pr_info("%s reset to defaults\n", object_type[do_characters]);
  94         } else if (received) {
  95                 len = snprintf(buf, sizeof(buf),
  96                                " updated %d of %d %s\n",
  97                                used, received, object_type[do_characters]);
  98                 if (rejected)
  99                         snprintf(buf + (len - 1), sizeof(buf) - (len - 1),
 100                                  " with %d reject%s\n",
 101                                  rejected, rejected > 1 ? "s" : "");
 102                 pr_info("%s", buf);
 103         }
 104 }
 105
 106 /*
 107  * This is called when a user changes the characters or chartab parameters.
 108  */
 109 static ssize_t chars_chartab_store(struct kobject *kobj,
 110                                    struct kobj_attribute *attr,
 111                                    const char *buf, size_t count)
 112 {
 113         char *cp = (char *)buf;
 114         char *end = cp + count; /* the null at the end of the buffer */
 115         char *linefeed = NULL;
 116         char keyword[MAX_DESC_LEN + 1];
 117         char *outptr = NULL;    /* Will hold keyword or desc. */
 118         char *temp = NULL;
 119         char *desc = NULL;
 120         ssize_t retval = count;
 121         unsigned long flags;
 122         unsigned long index = 0;
 123         int charclass = 0;
 124         int received = 0;
 125         int used = 0;
 126         int rejected = 0;
 127         int reset = 0;
 128         int do_characters = !strcmp(attr->attr.name, "characters");
 129         size_t desc_length = 0;
 130         int i;
 131
 132         spin_lock_irqsave(&speakup_info.spinlock, flags);
 133         while (cp < end) {
 134                 while ((cp < end) && (*cp == ' ' || *cp == '\t'))
 135                         cp++;
 136
 137                 if (cp == end)
 138                         break;
 139                 if ((*cp == '\n') || strchr("dDrR", *cp)) {
 140                         reset = 1;
 141                         break;
 142                 }
 143                 received++;
 144
 145                 linefeed = strchr(cp, '\n');
 146                 if (!linefeed) {
 147                         rejected++;
 148                         break;
 149                 }
 150
 151                 if (!isdigit(*cp)) {
 152                         rejected++;
 153                         cp = linefeed + 1;
 154                         continue;
 155                 }
 156
 157                 /*
 158                  * Do not replace with kstrtoul:
 159                  * here we need temp to be updated
 160                  */
 161                 index = simple_strtoul(cp, &temp, 10);
 162                 if (index > 255) {
 163                         rejected++;
 164                         cp = linefeed + 1;
 165                         continue;
 166                 }
 167
 168                 while ((temp < linefeed) && (*temp == ' ' || *temp == '\t'))
 169                         temp++;
 170
 171                 desc_length = linefeed - temp;
 172                 if (desc_length > MAX_DESC_LEN) {
 173                         rejected++;
 174                         cp = linefeed + 1;
 175                         continue;
 176                 }
 177                 if (do_characters) {
 178                         desc = kmalloc(desc_length + 1, GFP_ATOMIC);
 179                         if (!desc) {
 180                                 retval = -ENOMEM;
 181                                 reset = 1;      /* just reset on error. */
 182                                 break;
 183                         }
 184                         outptr = desc;
 185                 } else {
 186                         outptr = keyword;
 187                 }
 188
 189                 for (i = 0; i < desc_length; i++)
 190                         outptr[i] = temp[i];
 191                 outptr[desc_length] = '\0';
 192
 193                 if (do_characters) {
 194                         if (spk_characters[index] != spk_default_chars[index])
 195                                 kfree(spk_characters[index]);
 196                         spk_characters[index] = desc;
 197                         used++;
 198                 } else {
 199                         charclass = spk_chartab_get_value(keyword);
 200                         if (charclass == 0) {
 201                                 rejected++;
 202                                 cp = linefeed + 1;
 203                                 continue;
 204                         }
 205                         if (charclass != spk_chartab[index]) {
 206                                 spk_chartab[index] = charclass;
 207                                 used++;
 208                         }
 209                 }
 210                 cp = linefeed + 1;
 211         }
 212
 213         if (reset) {
 214                 if (do_characters)
 215                         spk_reset_default_chars();
 216                 else
 217                         spk_reset_default_chartab();
 218         }
 219
 220         spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 221         report_char_chartab_status(reset, received, used, rejected,
 222                                    do_characters);
 223         return retval;
 224 }
 225
 226 /*
 227  * This is called when a user reads the keymap parameter.
 228  */
 229 static ssize_t keymap_show(struct kobject *kobj, struct kobj_attribute *attr,
 230                            char *buf)
 231 {
 232         char *cp = buf;
 233         int i;
 234         int n;
 235         int num_keys;
 236         int nstates;
 237         u_char *cp1;
 238         u_char ch;
 239         unsigned long flags;
 240
 241         spin_lock_irqsave(&speakup_info.spinlock, flags);
 242         cp1 = spk_key_buf + SHIFT_TBL_SIZE;
 243         num_keys = (int)(*cp1);
 244         nstates = (int)cp1[1];
 245         cp += sprintf(cp, "%d, %d, %d,\n", KEY_MAP_VER, num_keys, nstates);
 246         cp1 += 2; /* now pointing at shift states */
 247         /* dump num_keys+1 as first row is shift states + flags,
 248          * each subsequent row is key + states
 249          */
 250         for (n = 0; n <= num_keys; n++) {
 251                 for (i = 0; i <= nstates; i++) {
 252                         ch = *cp1++;
 253                         cp += sprintf(cp, "%d,", (int)ch);
 254                         *cp++ = (i < nstates) ? SPACE : '\n';
 255                 }
 256         }
 257         cp += sprintf(cp, "0, %d\n", KEY_MAP_VER);
 258         spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 259         return (int)(cp - buf);
 260 }
 261
 262 /*
 263  * This is called when a user changes the keymap parameter.
 264  */
 265 static ssize_t keymap_store(struct kobject *kobj, struct kobj_attribute *attr,
 266                             const char *buf, size_t count)
 267 {
 268         int i;
 269         ssize_t ret = count;
 270         char *in_buff = NULL;
 271         char *cp;
 272         u_char *cp1;
 273         unsigned long flags;
 274
 275         spin_lock_irqsave(&speakup_info.spinlock, flags);
 276         in_buff = kmemdup(buf, count + 1, GFP_ATOMIC);
 277         if (!in_buff) {
 278                 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 279                 return -ENOMEM;
 280         }
 281         if (strchr("dDrR", *in_buff)) {
 282                 spk_set_key_info(spk_key_defaults, spk_key_buf);
 283                 pr_info("keymap set to default values\n");
 284                 kfree(in_buff);
 285                 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 286                 return count;
 287         }
 288         if (in_buff[count - 1] == '\n')
 289                 in_buff[count - 1] = '\0';
 290         cp = in_buff;
 291         cp1 = (u_char *)in_buff;
 292         for (i = 0; i < 3; i++) {
 293                 cp = spk_s2uchar(cp, cp1);
 294                 cp1++;
 295         }
 296         i = (int)cp1[-2] + 1;
 297         i *= (int)cp1[-1] + 1;
 298         i += 2; /* 0 and last map ver */
 299         if (cp1[-3] != KEY_MAP_VER || cp1[-1] > 10 ||
 300             i + SHIFT_TBL_SIZE + 4 >= sizeof(spk_key_buf)) {
 301                 pr_warn("i %d %d %d %d\n", i,
 302                         (int)cp1[-3], (int)cp1[-2], (int)cp1[-1]);
 303                 kfree(in_buff);
 304                 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 305                 return -EINVAL;
 306         }
 307         while (--i >= 0) {
 308                 cp = spk_s2uchar(cp, cp1);
 309                 cp1++;
 310                 if (!(*cp))
 311                         break;
 312         }
 313         if (i != 0 || cp1[-1] != KEY_MAP_VER || cp1[-2] != 0) {
 314                 ret = -EINVAL;
 315                 pr_warn("end %d %d %d %d\n", i,
 316                         (int)cp1[-3], (int)cp1[-2], (int)cp1[-1]);
 317         } else {
 318                 if (spk_set_key_info(in_buff, spk_key_buf)) {
 319                         spk_set_key_info(spk_key_defaults, spk_key_buf);
 320                         ret = -EINVAL;
 321                         pr_warn("set key failed\n");
 322                 }
 323         }
 324         kfree(in_buff);
 325         spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 326         return ret;
 327 }
 328
 329 /*
 330  * This is called when a user changes the value of the silent parameter.
 331  */
 332 static ssize_t silent_store(struct kobject *kobj, struct kobj_attribute *attr,
 333                             const char *buf, size_t count)
 334 {
 335         int len;
 336         struct vc_data *vc = vc_cons[fg_console].d;
 337         char ch = 0;
 338         char shut;
 339         unsigned long flags;
 340
 341         len = strlen(buf);
 342         if (len > 0 && len < 3) {
 343                 ch = buf[0];
 344                 if (ch == '\n')
 345                         ch = '0';
 346         }
 347         if (ch < '0' || ch > '7') {
 348                 pr_warn("silent value '%c' not in range (0,7)\n", ch);
 349                 return -EINVAL;
 350         }
 351         spin_lock_irqsave(&speakup_info.spinlock, flags);
 352         if (ch & 2) {
 353                 shut = 1;
 354                 spk_do_flush();
 355         } else {
 356                 shut = 0;
 357         }
 358         if (ch & 4)
 359                 shut |= 0x40;
 360         if (ch & 1)
 361                 spk_shut_up |= shut;
 362         else
 363                 spk_shut_up &= ~shut;
 364         spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 365         return count;
 366 }
 367
 368 /*
 369  * This is called when a user reads the synth setting.
 370  */
 371 static ssize_t synth_show(struct kobject *kobj, struct kobj_attribute *attr,
 372                           char *buf)
 373 {
 374         int rv;
 375
 376         if (!synth)
 377                 rv = sprintf(buf, "%s\n", "none");
 378         else
 379                 rv = sprintf(buf, "%s\n", synth->name);
 380         return rv;
 381 }
 382
 383 /*
 384  * This is called when a user requests to change synthesizers.
 385  */
 386 static ssize_t synth_store(struct kobject *kobj, struct kobj_attribute *attr,
 387                            const char *buf, size_t count)
 388 {
 389         int len;
 390         char new_synth_name[10];
 391
 392         len = strlen(buf);
 393         if (len < 2 || len > 9)
 394                 return -EINVAL;
 395         memcpy(new_synth_name, buf, len);
 396         if (new_synth_name[len - 1] == '\n')
 397                 len--;
 398         new_synth_name[len] = '\0';
 399         spk_strlwr(new_synth_name);
 400         if (synth && !strcmp(new_synth_name, synth->name)) {
 401                 pr_warn("%s already in use\n", new_synth_name);
 402         } else if (synth_init(new_synth_name) != 0) {
 403                 pr_warn("failed to init synth %s\n", new_synth_name);
 404                 return -ENODEV;
 405         }
 406         return count;
 407 }
 408
 409 /*
 410  * This is called when text is sent to the synth via the synth_direct file.
 411  */
 412 static ssize_t synth_direct_store(struct kobject *kobj,
 413                                   struct kobj_attribute *attr,
 414                                   const char *buf, size_t count)
 415 {
 416         char *unescaped;
 417         unsigned long flags;
 418
 419         if (!synth)
 420                 return -EPERM;
 421
 422         unescaped = kstrdup(buf, GFP_KERNEL);
 423         if (!unescaped)
 424                 return -ENOMEM;
 425
 426         string_unescape_any_inplace(unescaped);
 427
 428         spin_lock_irqsave(&speakup_info.spinlock, flags);
 429         synth_write(unescaped, strlen(unescaped));
 430         spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 431
 432         kfree(unescaped);
 433
 434         return count;
 435 }
 436
 437 /*
 438  * This function is called when a user reads the version.
 439  */
 440 static ssize_t version_show(struct kobject *kobj, struct kobj_attribute *attr,
 441                             char *buf)
 442 {
 443         char *cp;
 444
 445         cp = buf;
 446         cp += sprintf(cp, "Speakup version %s\n", SPEAKUP_VERSION);
 447         if (synth)
 448                 cp += sprintf(cp, "%s synthesizer driver version %s\n",
 449                 synth->name, synth->version);
 450         return cp - buf;
 451 }
 452
 453 /*
 454  * This is called when a user reads the punctuation settings.
 455  */
 456 static ssize_t punc_show(struct kobject *kobj, struct kobj_attribute *attr,
 457                          char *buf)
 458 {
 459         int i;
 460         char *cp = buf;
 461         struct st_var_header *p_header;
 462         struct punc_var_t *var;
 463         struct st_bits_data *pb;
 464         short mask;
 465         unsigned long flags;
 466
 467         p_header = spk_var_header_by_name(attr->attr.name);
 468         if (!p_header) {
 469                 pr_warn("p_header is null, attr->attr.name is %s\n",
 470                         attr->attr.name);
 471                 return -EINVAL;
 472         }
 473
 474         var = spk_get_punc_var(p_header->var_id);
 475         if (!var) {
 476                 pr_warn("var is null, p_header->var_id is %i\n",
 477                         p_header->var_id);
 478                 return -EINVAL;
 479         }
 480
 481         spin_lock_irqsave(&speakup_info.spinlock, flags);
 482         pb = (struct st_bits_data *)&spk_punc_info[var->value];
 483         mask = pb->mask;
 484         for (i = 33; i < 128; i++) {
 485                 if (!(spk_chartab[i] & mask))
 486                         continue;
 487                 *cp++ = (char)i;
 488         }
 489         spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 490         return cp - buf;
 491 }
 492
 493 /*
 494  * This is called when a user changes the punctuation settings.
 495  */
 496 static ssize_t punc_store(struct kobject *kobj, struct kobj_attribute *attr,
 497                           const char *buf, size_t count)
 498 {
 499         int x;
 500         struct st_var_header *p_header;
 501         struct punc_var_t *var;
 502         char punc_buf[100];
 503         unsigned long flags;
 504
 505         x = strlen(buf);
 506         if (x < 1 || x > 99)
 507                 return -EINVAL;
 508
 509         p_header = spk_var_header_by_name(attr->attr.name);
 510         if (!p_header) {
 511                 pr_warn("p_header is null, attr->attr.name is %s\n",
 512                         attr->attr.name);
 513                 return -EINVAL;
 514         }
 515
 516         var = spk_get_punc_var(p_header->var_id);
 517         if (!var) {
 518                 pr_warn("var is null, p_header->var_id is %i\n",
 519                         p_header->var_id);
 520                 return -EINVAL;
 521         }
 522
 523         memcpy(punc_buf, buf, x);
 524
 525         while (x && punc_buf[x - 1] == '\n')
 526                 x--;
 527         punc_buf[x] = '\0';
 528
 529         spin_lock_irqsave(&speakup_info.spinlock, flags);
 530
 531         if (*punc_buf == 'd' || *punc_buf == 'r')
 532                 x = spk_set_mask_bits(NULL, var->value, 3);
 533         else
 534                 x = spk_set_mask_bits(punc_buf, var->value, 3);
 535
 536         spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 537         return count;
 538 }
 539
 540 /*
 541  * This function is called when a user reads one of the variable parameters.
 542  */
 543 ssize_t spk_var_show(struct kobject *kobj, struct kobj_attribute *attr,
 544                      char *buf)
 545 {
 546         int rv = 0;
 547         struct st_var_header *param;
 548         struct var_t *var;
 549         char *cp1;
 550         char *cp;
 551         char ch;
 552         unsigned long flags;
 553
 554         param = spk_var_header_by_name(attr->attr.name);
 555         if (!param)
 556                 return -EINVAL;
 557
 558         spin_lock_irqsave(&speakup_info.spinlock, flags);
 559         var = (struct var_t *)param->data;
 560         switch (param->var_type) {
 561         case VAR_NUM:
 562         case VAR_TIME:
 563                 if (var)
 564                         rv = sprintf(buf, "%i\n", var->u.n.value);
 565                 else
 566                         rv = sprintf(buf, "0\n");
 567                 break;
 568         case VAR_STRING:
 569                 if (var) {
 570                         cp1 = buf;
 571                         *cp1++ = '"';
 572                         for (cp = (char *)param->p_val; (ch = *cp); cp++) {
 573                                 if (ch >= ' ' && ch < '~')
 574                                         *cp1++ = ch;
 575                                 else
 576                                         cp1 += sprintf(cp1, "\\x%02x", ch);
 577                         }
 578                         *cp1++ = '"';
 579                         *cp1++ = '\n';
 580                         *cp1 = '\0';
 581                         rv = cp1 - buf;
 582                 } else {
 583                         rv = sprintf(buf, "\"\"\n");
 584                 }
 585                 break;
 586         default:
 587                 rv = sprintf(buf, "Bad parameter  %s, type %i\n",
 588                              param->name, param->var_type);
 589                 break;
 590         }
 591         spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 592         return rv;
 593 }
 594 EXPORT_SYMBOL_GPL(spk_var_show);
 595
 596 /*
 597  * Used to reset either default_pitch or default_vol.
 598  */
 599 static inline void spk_reset_default_value(char *header_name,
 600                                            int *synth_default_value, int idx)
 601 {
 602         struct st_var_header *param;
 603
 604         if (synth && synth_default_value) {
 605                 param = spk_var_header_by_name(header_name);
 606                 if (param)  {
 607                         spk_set_num_var(synth_default_value[idx],
 608                                         param, E_NEW_DEFAULT);
 609                         spk_set_num_var(0, param, E_DEFAULT);
 610                         pr_info("%s reset to default value\n", param->name);
 611                 }
 612         }
 613 }
 614
 615 /*
 616  * This function is called when a user echos a value to one of the
 617  * variable parameters.
 618  */
 619 ssize_t spk_var_store(struct kobject *kobj, struct kobj_attribute *attr,
 620                       const char *buf, size_t count)
 621 {
 622         struct st_var_header *param;
 623         int ret;
 624         int len;
 625         char *cp;
 626         struct var_t *var_data;
 627         long value;
 628         unsigned long flags;
 629
 630         param = spk_var_header_by_name(attr->attr.name);
 631         if (!param)
 632                 return -EINVAL;
 633         if (!param->data)
 634                 return 0;
 635         ret = 0;
 636         cp = (char *)buf;
 637         string_unescape_any_inplace(cp);
 638
 639         spin_lock_irqsave(&speakup_info.spinlock, flags);
 640         switch (param->var_type) {
 641         case VAR_NUM:
 642         case VAR_TIME:
 643                 if (*cp == 'd' || *cp == 'r' || *cp == '\0')
 644                         len = E_DEFAULT;
 645                 else if (*cp == '+' || *cp == '-')
 646                         len = E_INC;
 647                 else
 648                         len = E_SET;
 649                 if (kstrtol(cp, 10, &value) == 0)
 650                         ret = spk_set_num_var(value, param, len);
 651                 else
 652                         pr_warn("overflow or parsing error has occurred");
 653                 if (ret == -ERANGE) {
 654                         var_data = param->data;
 655                         pr_warn("value for %s out of range, expect %d to %d\n",
 656                                 param->name,
 657                                 var_data->u.n.low, var_data->u.n.high);
 658                 }
 659
 660                /*
 661                 * If voice was just changed, we might need to reset our default
 662                 * pitch and volume.
 663                 */
 664                 if (param->var_id == VOICE && synth &&
 665                     (ret == 0 || ret == -ERESTART)) {
 666                         var_data = param->data;
 667                         value = var_data->u.n.value;
 668                         spk_reset_default_value("pitch", synth->default_pitch,
 669                                                 value);
 670                         spk_reset_default_value("vol", synth->default_vol,
 671                                                 value);
 672                 }
 673                 break;
 674         case VAR_STRING:
 675                 len = strlen(cp);
 676                 if ((len >= 1) && (cp[len - 1] == '\n'))
 677                         --len;
 678                 if ((len >= 2) && (cp[0] == '"') && (cp[len - 1] == '"')) {
 679                         ++cp;
 680                         len -= 2;
 681                 }
 682                 cp[len] = '\0';
 683                 ret = spk_set_string_var(cp, param, len);
 684                 if (ret == -E2BIG)
 685                         pr_warn("value too long for %s\n",
 686                                 param->name);
 687                 break;
 688         default:
 689                 pr_warn("%s unknown type %d\n",
 690                         param->name, (int)param->var_type);
 691         break;
 692         }
 693         spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 694
 695         if (ret == -ERESTART)
 696                 pr_info("%s reset to default value\n", param->name);
 697         return count;
 698 }
 699 EXPORT_SYMBOL_GPL(spk_var_store);
 700
 701 /*
 702  * Functions for reading and writing lists of i18n messages.  Incomplete.
 703  */
 704
 705 static ssize_t message_show_helper(char *buf, enum msg_index_t first,
 706                                    enum msg_index_t last)
 707 {
 708         size_t bufsize = PAGE_SIZE;
 709         char *buf_pointer = buf;
 710         int printed;
 711         enum msg_index_t cursor;
 712         int index = 0;
 713         *buf_pointer = '\0'; /* buf_pointer always looking at a NUL byte. */
 714
 715         for (cursor = first; cursor <= last; cursor++, index++) {
 716                 if (bufsize <= 1)
 717                         break;
 718                 printed = scnprintf(buf_pointer, bufsize, "%d\t%s\n",
 719                                     index, spk_msg_get(cursor));
 720                 buf_pointer += printed;
 721                 bufsize -= printed;
 722         }
 723
 724         return buf_pointer - buf;
 725 }
 726
 727 static void report_msg_status(int reset, int received, int used,
 728                               int rejected, char *groupname)
 729 {
 730         int len;
 731         char buf[160];
 732
 733         if (reset) {
 734                 pr_info("i18n messages from group %s reset to defaults\n",
 735                         groupname);
 736         } else if (received) {
 737                 len = snprintf(buf, sizeof(buf),
 738                                " updated %d of %d i18n messages from group %s\n",
 739                                        used, received, groupname);
 740                 if (rejected)
 741                         snprintf(buf + (len - 1), sizeof(buf) - (len - 1),
 742                                  " with %d reject%s\n",
 743                                  rejected, rejected > 1 ? "s" : "");
 744                 pr_info("%s", buf);
 745         }
 746 }
 747
 748 static ssize_t message_store_helper(const char *buf, size_t count,
 749                                     struct msg_group_t *group)
 750 {
 751         char *cp = (char *)buf;
 752         char *end = cp + count;
 753         char *linefeed = NULL;
 754         char *temp = NULL;
 755         ssize_t msg_stored = 0;
 756         ssize_t retval = count;
 757         size_t desc_length = 0;
 758         unsigned long index = 0;
 759         int received = 0;
 760         int used = 0;
 761         int rejected = 0;
 762         int reset = 0;
 763         enum msg_index_t firstmessage = group->start;
 764         enum msg_index_t lastmessage = group->end;
 765         enum msg_index_t curmessage;
 766
 767         while (cp < end) {
 768                 while ((cp < end) && (*cp == ' ' || *cp == '\t'))
 769                         cp++;
 770
 771                 if (cp == end)
 772                         break;
 773                 if (strchr("dDrR", *cp)) {
 774                         reset = 1;
 775                         break;
 776                 }
 777                 received++;
 778
 779                 linefeed = strchr(cp, '\n');
 780                 if (!linefeed) {
 781                         rejected++;
 782                         break;
 783                 }
 784
 785                 if (!isdigit(*cp)) {
 786                         rejected++;
 787                         cp = linefeed + 1;
 788                         continue;
 789                 }
 790
 791                 /*
 792                  * Do not replace with kstrtoul:
 793                  * here we need temp to be updated
 794                  */
 795                 index = simple_strtoul(cp, &temp, 10);
 796
 797                 while ((temp < linefeed) && (*temp == ' ' || *temp == '\t'))
 798                         temp++;
 799
 800                 desc_length = linefeed - temp;
 801                 curmessage = firstmessage + index;
 802
 803                 /*
 804                  * Note the check (curmessage < firstmessage).  It is not
 805                  * redundant.  Suppose that the user gave us an index
 806                  * equal to ULONG_MAX - 1.  If firstmessage > 1, then
 807                  * firstmessage + index < firstmessage!
 808                  */
 809
 810                 if ((curmessage < firstmessage) || (curmessage > lastmessage)) {
 811                         rejected++;
 812                         cp = linefeed + 1;
 813                         continue;
 814                 }
 815
 816                 msg_stored = spk_msg_set(curmessage, temp, desc_length);
 817                 if (msg_stored < 0) {
 818                         retval = msg_stored;
 819                         if (msg_stored == -ENOMEM)
 820                                 reset = 1;
 821                         break;
 822                 }
 823
 824                 used++;
 825
 826                 cp = linefeed + 1;
 827         }
 828
 829         if (reset)
 830                 spk_reset_msg_group(group);
 831
 832         report_msg_status(reset, received, used, rejected, group->name);
 833         return retval;
 834 }
 835
 836 static ssize_t message_show(struct kobject *kobj,
 837                             struct kobj_attribute *attr, char *buf)
 838 {
 839         ssize_t retval = 0;
 840         struct msg_group_t *group = spk_find_msg_group(attr->attr.name);
 841         unsigned long flags;
 842
 843         if (WARN_ON(!group))
 844                 return -EINVAL;
 845
 846         spin_lock_irqsave(&speakup_info.spinlock, flags);
 847         retval = message_show_helper(buf, group->start, group->end);
 848         spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 849         return retval;
 850 }
 851
 852 static ssize_t message_store(struct kobject *kobj, struct kobj_attribute *attr,
 853                              const char *buf, size_t count)
 854 {
 855         struct msg_group_t *group = spk_find_msg_group(attr->attr.name);
 856
 857         if (WARN_ON(!group))
 858                 return -EINVAL;
 859
 860         return message_store_helper(buf, count, group);
 861 }
 862
 863 /*
 864  * Declare the attributes.
 865  */
 866 static struct kobj_attribute keymap_attribute =
 867         __ATTR_RW(keymap);
 868 static struct kobj_attribute silent_attribute =
 869         __ATTR_WO(silent);
 870 static struct kobj_attribute synth_attribute =
 871         __ATTR_RW(synth);
 872 static struct kobj_attribute synth_direct_attribute =
 873         __ATTR_WO(synth_direct);
 874 static struct kobj_attribute version_attribute =
 875         __ATTR_RO(version);
 876
 877 static struct kobj_attribute delimiters_attribute =
 878         __ATTR(delimiters, 0644, punc_show, punc_store);
 879 static struct kobj_attribute ex_num_attribute =
 880         __ATTR(ex_num, 0644, punc_show, punc_store);
 881 static struct kobj_attribute punc_all_attribute =
 882         __ATTR(punc_all, 0644, punc_show, punc_store);
 883 static struct kobj_attribute punc_most_attribute =
 884         __ATTR(punc_most, 0644, punc_show, punc_store);
 885 static struct kobj_attribute punc_some_attribute =
 886         __ATTR(punc_some, 0644, punc_show, punc_store);
 887 static struct kobj_attribute repeats_attribute =
 888         __ATTR(repeats, 0644, punc_show, punc_store);
 889
 890 static struct kobj_attribute attrib_bleep_attribute =
 891         __ATTR(attrib_bleep, 0644, spk_var_show, spk_var_store);
 892 static struct kobj_attribute bell_pos_attribute =
 893         __ATTR(bell_pos, 0644, spk_var_show, spk_var_store);
 894 static struct kobj_attribute bleep_time_attribute =
 895         __ATTR(bleep_time, 0644, spk_var_show, spk_var_store);
 896 static struct kobj_attribute bleeps_attribute =
 897         __ATTR(bleeps, 0644, spk_var_show, spk_var_store);
 898 static struct kobj_attribute cursor_time_attribute =
 899         __ATTR(cursor_time, 0644, spk_var_show, spk_var_store);
 900 static struct kobj_attribute key_echo_attribute =
 901         __ATTR(key_echo, 0644, spk_var_show, spk_var_store);
 902 static struct kobj_attribute no_interrupt_attribute =
 903         __ATTR(no_interrupt, 0644, spk_var_show, spk_var_store);
 904 static struct kobj_attribute punc_level_attribute =
 905         __ATTR(punc_level, 0644, spk_var_show, spk_var_store);
 906 static struct kobj_attribute reading_punc_attribute =
 907         __ATTR(reading_punc, 0644, spk_var_show, spk_var_store);
 908 static struct kobj_attribute say_control_attribute =
 909         __ATTR(say_control, 0644, spk_var_show, spk_var_store);
 910 static struct kobj_attribute say_word_ctl_attribute =
 911         __ATTR(say_word_ctl, 0644, spk_var_show, spk_var_store);
 912 static struct kobj_attribute spell_delay_attribute =
 913         __ATTR(spell_delay, 0644, spk_var_show, spk_var_store);
 914 static struct kobj_attribute cur_phonetic_attribute =
 915         __ATTR(cur_phonetic, 0644, spk_var_show, spk_var_store);
 916
 917 /*
 918  * These attributes are i18n related.
 919  */
 920 static struct kobj_attribute announcements_attribute =
 921         __ATTR(announcements, 0644, message_show, message_store);
 922 static struct kobj_attribute characters_attribute =
 923         __ATTR(characters, 0644, chars_chartab_show,
 924                chars_chartab_store);
 925 static struct kobj_attribute chartab_attribute =
 926         __ATTR(chartab, 0644, chars_chartab_show,
 927                chars_chartab_store);
 928 static struct kobj_attribute ctl_keys_attribute =
 929         __ATTR(ctl_keys, 0644, message_show, message_store);
 930 static struct kobj_attribute colors_attribute =
 931         __ATTR(colors, 0644, message_show, message_store);
 932 static struct kobj_attribute formatted_attribute =
 933         __ATTR(formatted, 0644, message_show, message_store);
 934 static struct kobj_attribute function_names_attribute =
 935         __ATTR(function_names, 0644, message_show, message_store);
 936 static struct kobj_attribute key_names_attribute =
 937         __ATTR(key_names, 0644, message_show, message_store);
 938 static struct kobj_attribute states_attribute =
 939         __ATTR(states, 0644, message_show, message_store);
 940
 941 /*
 942  * Create groups of attributes so that we can create and destroy them all
 943  * at once.
 944  */
 945 static struct attribute *main_attrs[] = {
 946         &keymap_attribute.attr,
 947         &silent_attribute.attr,
 948         &synth_attribute.attr,
 949         &synth_direct_attribute.attr,
 950         &version_attribute.attr,
 951         &delimiters_attribute.attr,
 952         &ex_num_attribute.attr,
 953         &punc_all_attribute.attr,
 954         &punc_most_attribute.attr,
 955         &punc_some_attribute.attr,
 956         &repeats_attribute.attr,
 957         &attrib_bleep_attribute.attr,
 958         &bell_pos_attribute.attr,
 959         &bleep_time_attribute.attr,
 960         &bleeps_attribute.attr,
 961         &cursor_time_attribute.attr,
 962         &key_echo_attribute.attr,
 963         &no_interrupt_attribute.attr,
 964         &punc_level_attribute.attr,
 965         &reading_punc_attribute.attr,
 966         &say_control_attribute.attr,
 967         &say_word_ctl_attribute.attr,
 968         &spell_delay_attribute.attr,
 969         &cur_phonetic_attribute.attr,
 970         NULL,
 971 };
 972
 973 static struct attribute *i18n_attrs[] = {
 974         &announcements_attribute.attr,
 975         &characters_attribute.attr,
 976         &chartab_attribute.attr,
 977         &ctl_keys_attribute.attr,
 978         &colors_attribute.attr,
 979         &formatted_attribute.attr,
 980         &function_names_attribute.attr,
 981         &key_names_attribute.attr,
 982         &states_attribute.attr,
 983         NULL,
 984 };
 985
 986 /*
 987  * An unnamed attribute group will put all of the attributes directly in
 988  * the kobject directory.  If we specify a name, a subdirectory will be
 989  * created for the attributes with the directory being the name of the
 990  * attribute group.
 991  */
 992 static const struct attribute_group main_attr_group = {
 993         .attrs = main_attrs,
 994 };
 995
 996 static const struct attribute_group i18n_attr_group = {
 997         .attrs = i18n_attrs,
 998         .name = "i18n",
 999 };
1000
1001 static struct kobject *accessibility_kobj;
1002 struct kobject *speakup_kobj;
1003
1004 int speakup_kobj_init(void)
1005 {
1006         int retval;
1007
1008         /*
1009          * Create a simple kobject with the name of "accessibility",
1010          * located under /sys/
1011          *
1012          * As this is a simple directory, no uevent will be sent to
1013          * userspace.  That is why this function should not be used for
1014          * any type of dynamic kobjects, where the name and number are
1015          * not known ahead of time.
1016          */
1017         accessibility_kobj = kobject_create_and_add("accessibility", NULL);
1018         if (!accessibility_kobj) {
1019                 retval = -ENOMEM;
1020                 goto out;
1021         }
1022
1023         speakup_kobj = kobject_create_and_add("speakup", accessibility_kobj);
1024         if (!speakup_kobj) {
1025                 retval = -ENOMEM;
1026                 goto err_acc;
1027         }
1028
1029         /* Create the files associated with this kobject */
1030         retval = sysfs_create_group(speakup_kobj, &main_attr_group);
1031         if (retval)
1032                 goto err_speakup;
1033
1034         retval = sysfs_create_group(speakup_kobj, &i18n_attr_group);
1035         if (retval)
1036                 goto err_group;
1037
1038         goto out;
1039
1040 err_group:
1041         sysfs_remove_group(speakup_kobj, &main_attr_group);
1042 err_speakup:
1043         kobject_put(speakup_kobj);
1044 err_acc:
1045         kobject_put(accessibility_kobj);
1046 out:
1047         return retval;
1048 }
1049
1050 void speakup_kobj_exit(void)
1051 {
1052         sysfs_remove_group(speakup_kobj, &i18n_attr_group);
1053         sysfs_remove_group(speakup_kobj, &main_attr_group);
1054         kobject_put(speakup_kobj);
1055         kobject_put(accessibility_kobj);
1056 }