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         "IDS_ST_BODY_DATE_AND_TIME",
  94         "IDS_ST_BODY_SET_DATE_AND_TIME"
  95 };
  96
  97 static void _log(char *msg)
  98 {
  99         FILE *fp;
 100
 101         fp = fopen(LOGFILE, "a");
 102         if (fp == NULL)
 103                 return;
 104         fprintf(fp, "%s\n", msg);
 105         fclose(fp);
 106 }
 107
 108 void pwlock_log(char *fmt, ...)
 109 {
 110         va_list ap;
 111         char buf[LINEMAX];
 112
 113         va_start(ap, fmt);
 114         vsnprintf(buf, sizeof(buf), fmt, ap);
 115         va_end(ap);
 116
 117         _log(buf);
 118 }
 119
 120 void pwlock_log_t(char *fmt, ...)
 121 {
 122         va_list ap;
 123         FILE *fd = 0;
 124         char buf[LINEMAX] = { 0, };
 125         char debugString[LINEMAX] = { 0, };
 126
 127         va_start(ap, fmt);
 128         vsnprintf(buf, sizeof(buf), fmt, ap);
 129         va_end(ap);
 130         int fileLen = 0;
 131         struct tm local_t;
 132         time_t current_time = 0;
 133         bzero((char *)&debugString, LINEMAX);
 134         time(&current_time);
 135         gmtime_r(&current_time, &local_t);      /* for prevent 53555 */
 136         int len = snprintf(debugString, sizeof(debugString),
 137                            "[%d-%02d-%02d, %02d:%02d:%02d]: ",
 138                            local_t.tm_year + 1900, local_t.tm_mon + 1,
 139                            local_t.tm_mday, local_t.tm_hour, local_t.tm_min,
 140                            local_t.tm_sec);
 141         if (len == -1) {
 142                 return;
 143         } else {
 144                 debugString[len] = '\0';
 145         }
 146         len = g_strlcat(debugString, buf, LINEMAX);
 147         if (len >= LINEMAX) {
 148                 /* TODO:ERROR handling */
 149                 return;
 150         } else {
 151                 debugString[len] = '\n';
 152         }
 153         /* FIXME this is for permission.. later we should fix and remove this... */
 154         if ((fd = fopen(LOGFILE, "at+")) == NULL) {
 155                 PWLOCK_ERR("File fopen fail for writing Pwlock information");
 156         } else {
 157                 int pid = -1;
 158                 if (fwrite(debugString, strlen(debugString), 1, fd) < 1) {
 159                         PWLOCK_ERR
 160                             ("File fwrite fail for writing Pwlock information");
 161                         fclose(fd);
 162                         if ((pid = fork()) < 0) {
 163                         } else if (pid == 0) {
 164                                 execl("/bin/rm", "rm", "-f", LOGFILE,
 165                                       (char *)0);
 166                         }
 167                 } else {
 168                         fseek(fd, 0l, SEEK_END);
 169                         fileLen = ftell(fd);
 170                         if (fileLen > MAXFILELEN) {
 171                                 fclose(fd);
 172                                 if ((pid = fork()) < 0) {
 173                                         return;
 174                                 } else if (pid == 0) {
 175                                         execl("/bin/rm", "rm", "-f", LOGFILE,
 176                                               (char *)0);
 177                                 }
 178                         } else
 179                                 fclose(fd);
 180                 }
 181         }
 182 }
 183
 184 static void win_del(void *data, Evas_Object * obj, void *event)
 185 {
 186         elm_exit();
 187 }
 188
 189 Evas_Object *create_win(const char *name)
 190 {
 191         Evas_Object *eo;
 192         int w, h;
 193
 194         eo = elm_win_add(NULL, name, ELM_WIN_BASIC);
 195         if (eo) {
 196                 elm_win_title_set(eo, name);
 197                 elm_win_borderless_set(eo, EINA_TRUE);
 198                 elm_win_conformant_set(eo, EINA_TRUE);
 199                 evas_object_smart_callback_add(eo, "delete,request",
 200                                                win_del, NULL);
 201                 ecore_x_window_size_get(ecore_x_window_root_first_get(),
 202                                         &w, &h);
 203                 evas_object_resize(eo, w, h);
 204         }
 205
 206         return eo;
 207 }
 208
 209 Evas_Object *load_edj(Evas_Object * parent, const char *file, const char *group)
 210 {
 211         Evas_Object *eo;
 212         int r;
 213
 214         eo = elm_layout_add(parent);
 215         if (eo) {
 216                 r = elm_layout_file_set(eo, file, group);
 217                 if (!r) {
 218                         evas_object_del(eo);
 219                         return NULL;
 220                 }
 221
 222                 evas_object_size_hint_weight_set(eo,
 223                                                  EVAS_HINT_EXPAND,
 224                                                  EVAS_HINT_EXPAND);
 225         }
 226
 227         return eo;
 228 }
 229
 230 char *pwlock_get_string(int id)
 231 {
 232         _DBG("get string id : %d\n", id);
 233
 234         char *str = NULL;
 235
 236         if (id < IDS_PWLOCK_SYSTEM_STRING_MAX) {
 237                 /* get system string */
 238                 str = dgettext("sys_string", sys_str_table[id]);
 239         } else {
 240                 /* get application string */
 241                 str =
 242                     dgettext("pwlock",
 243                              app_str_table[id - IDS_PWLOCK_SYSTEM_STRING_MAX]);
 244         }
 245
 246         _DBG("get string : %s\n", str);
 247
 248         return str;
 249 }
 250
 251 void pwlock_tolower(char *src, char *dest)
 252 {
 253         int i;
 254         int src_len=0;
 255
 256         if (!src || !dest) {
 257                 _DBG(" src=%p, dest=%p\n", src, dest);
 258                 return;
 259         }
 260         src_len = strlen(src);
 261         for(i=0;i<src_len;i++) {
 262                 dest[i] = tolower(src[i]);
 263         }
 264         dest[i] = '\0';
 265 }