src/lang.c

   1 /* lang.c - NeonServ v5.6
   2  * Copyright (C) 2011-2012  Philipp Kreil (pk910)
   3  *
   4  * This program is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  16  */
  17 #include "lang.h"
  18 #include "UserNode.h"
  19 #include "DBHelper.h"
  20 #include "mysqlConn.h"
  21
  22 #define DEFAULT_LANG_TAG "EN"
  23 #define DEFAULT_LANG_NAME "English"
  24
  25 static struct language **langdict;
  26 static struct language *lang_c;
  27
  28 void init_lang() {
  29     langdict = calloc(MAXLANGUAGES, sizeof(*langdict));
  30 }
  31
  32 void free_lang() {
  33
  34 }
  35
  36 void load_languages() {
  37     MYSQL_RES *res;
  38     MYSQL_ROW row;
  39     printf_mysql_query("SELECT `lang`, `text` FROM `language` WHERE `ident` = 'name'");
  40     res = mysql_use();
  41     while((row = mysql_fetch_row(res)) != NULL) {
  42         load_language(row[0], row[1]);
  43     }
  44 }
  45
  46 static struct language* add_language(char *langtag, char *langname) {
  47     int cindex;
  48     for(cindex = 0; cindex < MAXLANGUAGES; cindex++) {
  49         if(langdict[cindex] == NULL) break;
  50         if(!strcmp(langdict[cindex]->langname, langname) || !strcmp(langdict[cindex]->langtag, langtag))
  51             return langdict[cindex];
  52     }
  53     if(cindex == MAXLANGUAGES) return NULL;
  54     struct language *lang = malloc(sizeof(*lang));
  55     if (!lang) {
  56         perror("malloc() failed");
  57         return NULL;
  58     }
  59     lang->langtag = strdup(langtag);
  60     lang->langname = strdup(langname);
  61     struct language_table **entrys = calloc(27, sizeof(*entrys));
  62     lang->entrys = entrys;
  63     langdict[cindex] = lang;
  64     return lang;
  65 }
  66
  67 static int get_entry_index(const char *ident) {
  68     const char *underscore = strstr(ident, "_");
  69     if(!underscore || !(underscore[1] >= 65 && underscore[1] <= 90)) return 26;
  70     return (underscore[1] - 'A');
  71 }
  72
  73 void load_language(char *tag, char *name) {
  74     struct language *lang = get_language_by_tag(tag);
  75     if(lang == get_default_language()) return;
  76     if(lang) {
  77         //remove all entrys
  78         int cindex;
  79         struct language_table *entry, *next;
  80         for(cindex = 0; cindex < 27; cindex++) {
  81             for(entry = lang->entrys[cindex]; entry; entry = next) {
  82                 next = entry->next;
  83                 free(entry->ident);
  84                 free(entry->text);
  85                 free(entry);
  86             }
  87             lang->entrys[cindex] = NULL;
  88         }
  89     } else
  90         lang = add_language(tag, name);
  91     if(!lang) return;
  92     MYSQL_RES *res;
  93     MYSQL_ROW row;
  94     printf_mysql_query("SELECT `ident`, `text` FROM `language` WHERE `lang` = '%s' AND `ident` != 'name'", escape_string(tag));
  95     res = mysql_use();
  96     while((row = mysql_fetch_row(res)) != NULL) {
  97         register_language_string(lang, row[0], row[1]);
  98     }
  99 }
 100
 101 struct language* get_language_by_tag(char *tag) {
 102     int cindex;
 103     for(cindex = 0; cindex < MAXLANGUAGES; cindex++) {
 104         if(langdict[cindex] == NULL) break;
 105         if(!stricmp(langdict[cindex]->langtag, tag))
 106             return langdict[cindex];
 107     }
 108     return NULL;
 109 }
 110
 111 struct language* get_language_by_name(char *name) {
 112     int cindex;
 113     for(cindex = 0; cindex < MAXLANGUAGES; cindex++) {
 114         if(langdict[cindex] == NULL) break;
 115         if(!stricmp(langdict[cindex]->langname, name))
 116             return langdict[cindex];
 117     }
 118     return NULL;
 119 }
 120
 121 struct language* get_default_language() {
 122     if(lang_c == NULL)
 123         lang_c = add_language(DEFAULT_LANG_TAG, DEFAULT_LANG_NAME);
 124     return lang_c;
 125 }
 126
 127 void register_default_language_table(const struct default_language_entry *msgtab) {
 128     if(lang_c == NULL)
 129         lang_c = add_language(DEFAULT_LANG_TAG, DEFAULT_LANG_NAME);
 130     while(msgtab->ident) {
 131         register_language_string(lang_c, msgtab->ident, msgtab->text);
 132         msgtab++;
 133     }
 134 }
 135
 136 void register_language_string(struct language *lang, char *ident, char *text) {
 137     int cindex = get_entry_index(ident);
 138     struct language_table *lang_entry;
 139     for(lang_entry = lang->entrys[cindex]; lang_entry; lang_entry = lang_entry->next) {
 140         if(!strcmp(lang_entry->ident, ident)) break;
 141     }
 142     if(!lang_entry) {
 143         lang_entry = malloc(sizeof(*lang_entry));
 144         if (!lang_entry) {
 145             perror("malloc() failed");
 146             return;
 147         }
 148         lang_entry->ident = strdup(ident);
 149         lang_entry->next = lang->entrys[cindex];
 150         lang->entrys[cindex] = lang_entry;
 151     } else
 152         free(lang_entry->text); //free old text (new one will be set below)
 153     //replace all:
 154     //$b to \002
 155     //$k to \003
 156     char txt[MAXLEN];
 157     strcpy(txt, text);
 158     char tmp[MAXLEN];
 159     int tmppos = 0;
 160     char *a, *b = txt;
 161     do {
 162         a = strstr(b, "$");
 163         if(a) *a = '\0';
 164         tmppos += sprintf(tmp + tmppos, "%s", b);
 165         if(a) {
 166             switch(a[1]) {
 167                 case 'b':
 168                     tmp[tmppos++] = 2;
 169                     break;
 170                 case 'k':
 171                     tmp[tmppos++] = 3;
 172                     break;
 173                 case 'u':
 174                     tmp[tmppos++] = 31;
 175                     break;
 176                 default:
 177                     //unknown - just write it
 178                     tmppos += sprintf(tmp + tmppos, "$%c", a[1]);
 179             }
 180             b = a+2;
 181         }
 182     } while(a);
 183     lang_entry->text = strdup(tmp);
 184 }
 185
 186 char *get_language_string(struct UserNode *user, const char* msg_ident) {
 187     struct language* lang;
 188     if(user && (user->flags & USERFLAG_ISAUTHED)) {
 189         loadUserSettings(user);
 190         lang = user->language;
 191     } else
 192         lang = lang_c;
 193     int cindex = get_entry_index(msg_ident);
 194     struct language_table* entry;
 195     for(entry = lang->entrys[cindex]; entry; entry = entry->next) {
 196         if(!strcmp(entry->ident, msg_ident))
 197             return entry->text;
 198     }
 199     if(lang == lang_c) return NULL;
 200     for(entry = lang_c->entrys[cindex]; entry; entry = entry->next) {
 201         if(!strcmp(entry->ident, msg_ident))
 202             return entry->text;
 203     }
 204     return NULL;
 205 }
 206
 207 char *build_language_string(struct UserNode *user, char *buffer, const char *msg_ident, ...) {
 208     char *formatStr = get_language_string(user, msg_ident);
 209     if(!formatStr) return NULL;
 210     if(buffer == NULL) {
 211         buffer = (char *)malloc((MAXLEN+1) * sizeof(char));
 212         if (!buffer) {
 213             perror("malloc() failed");
 214             return NULL;
 215         }
 216     }
 217     int pos;
 218     va_list arg_list;
 219     buffer[0] = '\0';
 220     va_start(arg_list, msg_ident);
 221     pos = vsnprintf(buffer, MAXLEN - 2, formatStr, arg_list);
 222     va_end(arg_list);
 223     if (pos < 0 || pos > (MAXLEN - 2)) pos = MAXLEN - 2;
 224     buffer[pos] = '\0';
 225     return buffer;
 226 }