src/util.c

   1 /*
   2  *  pwlock
   3  *
   4  * Copyright 2012  Samsung Electronics Co., Ltd
   5  *
   6  * Licensed under the Flora License, Version 1.1 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *     http://floralicense.org/license/
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <stdio.h>
  21 #include <stdarg.h>
  22 #include <appcore-common.h>
  23 #include <Ecore_X.h>
  24 #include <Elementary.h>
  25 #include <fcntl.h>
  26 #include <sys/types.h>
  27 #include <sys/socket.h>
  28 #include <sys/un.h>
  29 #include <poll.h>
  30 #include <stdio.h>
  31 #include <libintl.h>
  32 #include <glib.h>
  33 #include <iniparser.h>
  34
  35 #include "util.h"
  36
  37 #define LINEMAX 256
  38 #define MAXFILELEN      1048576 /* 32000 */
  39
  40 #define PHLOCK_SOCK_PREFIX "/tmp/phlock"
  41 #define PHLOCK_SOCK_MAXBUFF 65535
  42
  43 const char *sys_str_table[] = {
  44         "IDS_COM_SK_DONE",      /* 0 */
  45         "IDS_COM_BODY_ENTER_PASSWORD",
  46         "IDS_COM_BODY_PREVIOUS",
  47         "IDS_COM_SK_NEXT",
  48         "IDS_COM_SK_OK",
  49         "IDS_COM_SK_CANCEL",
  50         "IDS_COM_SK_START"
  51 };
  52
  53 const char *app_str_table[] = {
  54         "IDS_IDLE_BODY_AUTOMATIC",
  55         "IDS_IDLE_HEADER_NETWORK_LOCK",
  56         "IDS_IDLE_HEADER_PIN_LOCK",
  57         "IDS_IDLE_HEADER_PUK_LOCK",
  58         "IDS_IDLE_HEADER_SIM_BLOCKED",
  59         "IDS_IDLE_HEADER_SIM_LOCK",
  60         "IDS_IDLE_BODY_1_ATTEMPT_LEFT",
  61         "IDS_IDLE_BODY_CORPORATE_PERSONALISATION_ON_ENTER_CONTROL_KEY",
  62         "IDS_IDLE_BODY_ENTER_NEW_PIN",
  63         "IDS_IDLE_BODY_ENTER_PIN",
  64         "IDS_IDLE_BODY_ENTER_PUK",
  65         "IDS_IDLE_BODY_INCORRECT_PIN",
  66         "IDS_IDLE_BODY_INCORRECT_PIN_TRY_AGAIN",
  67         "IDS_IDLE_BODY_NETWORK_PERSONALISATION_ON_ENTER_CONTROL_KEY",
  68         "IDS_IDLE_BODY_NETWORK_SUBSET_PERSONALISATION_ON_ENTER_CONTROL_KEY",
  69         "IDS_IDLE_BODY_PD_ATTEMPTS_LEFT",
  70         "IDS_IDLE_BODY_SERVICE_PROVIDER_PERSONALISATION_ON_ENTER_CONTROL_KEY",
  71         "IDS_IDLE_BODY_SIM_CARD_NOT_AVAILABLE_CONTACT_YOUR_SERVICE_PROVIDER",
  72         "IDS_IDLE_BODY_WRONG_PASSWORD",
  73         "IDS_IDLE_BUTTON_DIALER",
  74         "IDS_IDLE_HEADER_DISPLAY_LANGUAGE",
  75         "IDS_IDLE_BODY_PASSWORD_EMPTY",
  76         "IDS_IDLE_BODY_PD_TO_PD_DIGITS_REQUIRED",
  77         "Passwords do not match",       /* TODO: System string request */
  78         "PIN code has been changed",    /* TODO: String request */
  79         "SIM card error",       /* TODO: String request */
  80         "IDS_IDLE_POP_CHECKING_SIM_CARD_ING",
  81         "Welcome to your",      /* TODO: String request */
  82         "IDS_SCM_BODY_WELCOME_E",
  83         "IDS_STU_BODY_SELECT_LANGUAGE",
  84         "IDS_ST_SK_EMERGENCY_CALL",
  85         "IDS_ST_BODY_TAP_TO_SET_UP",
  86         "IDS_COM_SK_SKIP",
  87         "IDS_ST_BODY_INSTALTAB_FINISH",
  88         "IDS_STU_BODY_DEVICE_IS_SET_UP_AND_READY_TO_USE",
  89         "IDS_STU_POP_SETUP_COMPLETE",
  90         "IDS_COM_BODY_NO_SIM_CARD_IN_DEVICE",
  91         "IDS_STU_BODY_HOW_TO_INSERT_SIM_CARD_HELP_MSG",
  92         "IDS_ST_BUTTON_TRY_AGAIN_ABB"
  93 };
  94
  95 static void _log(char *msg)
  96 {
  97         FILE *fp;
  98
  99         fp = fopen(LOGFILE, "a");
 100         if (fp == NULL)
 101                 return;
 102         fprintf(fp, "%s\n", msg);
 103         fclose(fp);
 104 }
 105
 106 void pwlock_log(char *fmt, ...)
 107 {
 108         va_list ap;
 109         char buf[LINEMAX];
 110
 111         va_start(ap, fmt);
 112         vsnprintf(buf, sizeof(buf), fmt, ap);
 113         va_end(ap);
 114
 115         _log(buf);
 116 }
 117
 118 void pwlock_log_t(char *fmt, ...)
 119 {
 120         va_list ap;
 121         FILE *fd = 0;
 122         char buf[LINEMAX] = { 0, };
 123         char debugString[LINEMAX] = { 0, };
 124
 125         va_start(ap, fmt);
 126         vsnprintf(buf, sizeof(buf), fmt, ap);
 127         va_end(ap);
 128         int fileLen = 0;
 129         struct tm local_t;
 130         time_t current_time = 0;
 131         bzero((char *)&debugString, LINEMAX);
 132         time(&current_time);
 133         gmtime_r(&current_time, &local_t);      /* for prevent 53555 */
 134         int len = snprintf(debugString, sizeof(debugString),
 135                            "[%d-%02d-%02d, %02d:%02d:%02d]: ",
 136                            local_t.tm_year + 1900, local_t.tm_mon + 1,
 137                            local_t.tm_mday, local_t.tm_hour, local_t.tm_min,
 138                            local_t.tm_sec);
 139         if (len == -1) {
 140                 return;
 141         } else {
 142                 debugString[len] = '\0';
 143         }
 144         len = g_strlcat(debugString, buf, LINEMAX);
 145         if (len >= LINEMAX) {
 146                 /* TODO:ERROR handling */
 147                 return;
 148         } else {
 149                 debugString[len] = '\n';
 150         }
 151         /* FIXME this is for permission.. later we should fix and remove this... */
 152         if ((fd = fopen(LOGFILE, "at+")) == NULL) {
 153                 PWLOCK_ERR("File fopen fail for writing Pwlock information");
 154         } else {
 155                 int pid = -1;
 156                 if (fwrite(debugString, strlen(debugString), 1, fd) < 1) {
 157                         PWLOCK_ERR
 158                             ("File fwrite fail for writing Pwlock information");
 159                         fclose(fd);
 160                         if ((pid = fork()) < 0) {
 161                         } else if (pid == 0) {
 162                                 execl("/bin/rm", "rm", "-f", LOGFILE,
 163                                       (char *)0);
 164                         }
 165                 } else {
 166                         fseek(fd, 0l, SEEK_END);
 167                         fileLen = ftell(fd);
 168                         if (fileLen > MAXFILELEN) {
 169                                 fclose(fd);
 170                                 if ((pid = fork()) < 0) {
 171                                         return;
 172                                 } else if (pid == 0) {
 173                                         execl("/bin/rm", "rm", "-f", LOGFILE,
 174                                               (char *)0);
 175                                 }
 176                         } else
 177                                 fclose(fd);
 178                 }
 179         }
 180 }
 181
 182 static void win_del(void *data, Evas_Object * obj, void *event)
 183 {
 184         elm_exit();
 185 }
 186
 187 Evas_Object *create_win(const char *name)
 188 {
 189         Evas_Object *eo;
 190         int w, h;
 191
 192         eo = elm_win_add(NULL, name, ELM_WIN_BASIC);
 193         if (eo) {
 194                 elm_win_title_set(eo, name);
 195                 elm_win_borderless_set(eo, EINA_TRUE);
 196                 elm_win_conformant_set(eo, EINA_TRUE);
 197                 evas_object_smart_callback_add(eo, "delete,request",
 198                                                win_del, NULL);
 199                 ecore_x_window_size_get(ecore_x_window_root_first_get(),
 200                                         &w, &h);
 201                 evas_object_resize(eo, w, h);
 202         }
 203
 204         return eo;
 205 }
 206
 207 Evas_Object *load_edj(Evas_Object * parent, const char *file, const char *group)
 208 {
 209         Evas_Object *eo;
 210         int r;
 211
 212         eo = elm_layout_add(parent);
 213         if (eo) {
 214                 r = elm_layout_file_set(eo, file, group);
 215                 if (!r) {
 216                         evas_object_del(eo);
 217                         return NULL;
 218                 }
 219
 220                 evas_object_size_hint_weight_set(eo,
 221                                                  EVAS_HINT_EXPAND,
 222                                                  EVAS_HINT_EXPAND);
 223         }
 224
 225         return eo;
 226 }
 227
 228 char *pwlock_get_string(int id)
 229 {
 230         _DBG("get string id : %d\n", id);
 231
 232         char *str = NULL;
 233
 234         if (id < IDS_PWLOCK_SYSTEM_STRING_MAX) {
 235                 /* get system string */
 236                 str = dgettext("sys_string", sys_str_table[id]);
 237         } else {
 238                 /* get application string */
 239                 str =
 240                     dgettext("pwlock",
 241                              app_str_table[id - IDS_PWLOCK_SYSTEM_STRING_MAX]);
 242         }
 243
 244         _DBG("get string : %s\n", str);
 245
 246         return str;
 247 }
 248
 249 void pwlock_tolower(char *src, char *dest)
 250 {
 251         int i;
 252         int src_len=0;
 253
 254         if (!src || !dest) {
 255                 _DBG(" src=%p, dest=%p\n", src, dest);
 256                 return;
 257         }
 258         src_len = strlen(src);
 259         for(i=0;i<src_len;i++) {
 260                 dest[i] = tolower(src[i]);
 261         }
 262         dest[i] = '\0';
 263 }