server/src/ccatalog.cpp

   1 /*
   2  *  sensor-framework
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: JuHyun Kim <jh8212.kim@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22
  23
  24
  25 #include <stdio.h>
  26 #include <string.h>
  27 #include <stdlib.h>
  28 #include <errno.h>
  29 #include <common.h>
  30 #include <cobject_type.h>
  31 #include <ctrim.h>
  32 #include <clist.h>
  33 #include <ccatalog.h>
  34 #define TMP_BUF_SIZE    512
  35
  36 ccatalog::ccatalog()
  37 : m_head(NULL)
  38 , m_tail(NULL)
  39 {
  40 }
  41
  42 ccatalog::~ccatalog()
  43 {
  44         if (m_head) unload();
  45 }
  46
  47 bool ccatalog::load(const char *conf_file , char splitter_id)
  48 {
  49         FILE *fp;
  50         group_t *grp = NULL;
  51         desc_t *desc;
  52         char line_buffer[TMP_BUF_SIZE];
  53         char tmp_buffer[TMP_BUF_SIZE];
  54         int rtrim_num;
  55         int split_num = 0;
  56         int group_name_check = 0;
  57         char name[TMP_BUF_SIZE];
  58         char value[TMP_BUF_SIZE];
  59         char *ptr;
  60
  61         switch (splitter_id ) {
  62                 case SPLITTER_FOR_CONF_FILE:
  63                 case '=':
  64                         break;
  65                 case SPLITTER_FOR_CPU_INFO:
  66                 case ':':
  67                         if ( !m_head ) {
  68                                 try {
  69                                         grp = new group_t;
  70                                 } catch (...) {
  71                                         ERR("No memory");
  72                                         return false;
  73                                 }
  74                                 m_head = m_tail = grp;
  75                                 grp->name = strdup("CPU_INFO_TABLE");
  76                                 if (!grp->name) {
  77                                         ERR("Failed to allocate buffer for the tmp_buffer\n");
  78                                         delete grp;
  79                                         return false;
  80                                 }
  81                                 DBG("grp->name : %s\n",grp->name);
  82                                 grp->attr_cnt = 0;
  83
  84                                 grp->head = NULL;
  85                                 grp->tail = NULL;
  86                         } else {
  87                                 ERR("already CPU_INFO_TABLE exist !! cannot make again\n");
  88                                 return false;
  89                         }
  90                         break;
  91
  92                 default:
  93                         ERR("fail does not support splitter idx : %x",splitter_id);
  94                         return false;
  95         }
  96
  97         fp = fopen(conf_file, "r");
  98         if (!fp) {
  99                 return false;
 100         }
 101
 102         while (fgets(line_buffer, TMP_BUF_SIZE, fp)) {
 103                 ptr = ctrim::ltrim(line_buffer);
 104                 if (*ptr == '#') {
 105                         continue;
 106                 }
 107                 DBG("read line_buffer : %s\n",line_buffer);
 108
 109                 /* Replcate the last character if it was new line. */
 110                 if ( (ptr[strlen(ptr)-1] == '\n') || (ptr[strlen(ptr)-1] == '\r')) ptr[strlen(ptr)-1] = '\0';
 111
 112                 rtrim_num = ctrim::rtrim(ptr);
 113
 114                 switch (splitter_id ) {
 115                         case SPLITTER_FOR_CONF_FILE:
 116                         case '=':
 117                                 group_name_check = sscanf(ptr, "[%[^]] ", tmp_buffer);
 118                                 break;
 119                         case SPLITTER_FOR_CPU_INFO:
 120                         case ':':
 121                                 group_name_check = 0;
 122                                 break;
 123                 }
 124
 125                 if (group_name_check == 1) {
 126                         /* We have previous group, Just link it to the end of group list */
 127                         DBG("check tmp_buffer : %s\n",tmp_buffer);
 128                         if (grp) {
 129                                 if (m_tail) {
 130                                         grp->link(clist::AFTER, m_tail);
 131                                         m_tail = grp;
 132                                 } else {
 133                                         m_head = m_tail = grp;
 134                                 }
 135                         }
 136
 137                         try {
 138                                 grp = new group_t;
 139                         } catch (...) {
 140                                 ERR("No memory");
 141                                 fclose(fp);
 142                                 return false;
 143                         }
 144
 145                         grp->name = strdup(tmp_buffer);
 146                         DBG("grp->name : %s\n",grp->name);
 147                         if (!grp->name) {
 148                                 ERR("Failed to allocate buffer for the tmp_buffer\n");
 149                                 delete grp;
 150                                 fclose(fp);
 151                                 return false;
 152                         }
 153                         grp->attr_cnt = 0;
 154                         grp->head = NULL;
 155                         grp->tail = NULL;
 156                         continue;
 157                 }
 158
 159                 switch (splitter_id ) {
 160                         case SPLITTER_FOR_CONF_FILE:
 161                         case '=':
 162                                 split_num = sscanf(ptr, "%[^=]=%[^\n]", name, value);
 163                                 break;
 164                         case SPLITTER_FOR_CPU_INFO:
 165                         case ':':
 166                                 split_num = sscanf(ptr, "%[^:]:%[^\n]", name, value);
 167                                 DBG("split_num : %d , raw_name : [start]%s[end] , raw_value : [start]%s[end]\n",split_num ,name , value);
 168                                 break;
 169                         default:
 170                                 ERR("fail does not support splitter idx : %x",splitter_id);
 171                                 split_num = 0;
 172                                 break;
 173                 }
 174
 175                 if ( (split_num == 2) && (grp!=NULL) ) {
 176                         try {
 177                                 desc = new desc_t;
 178                         } catch (...) {
 179                                 ERR("Failed to allocate new description\n");
 180                                 free(grp->name);
 181                                 delete grp;
 182                                 fclose(fp);
 183                                 return false;
 184                         }
 185
 186                         ptr = ctrim::ltrim(name);
 187                         rtrim_num = ctrim::rtrim(ptr);
 188                         desc->name = strdup(ptr);
 189                         DBG("desc->name :%s[end]\n",desc->name);
 190
 191                         if (!desc->name) {
 192                                 ERR("Failed to allocate buffer for the name\n");
 193                                 free(grp->name);
 194                                 delete grp;
 195                                 delete desc;
 196                                 fclose(fp);
 197                                 return false;
 198                         }
 199
 200                         ptr = ctrim::ltrim(value);
 201                         rtrim_num = ctrim::rtrim(ptr);
 202                         desc->value = strdup(ptr);
 203                         DBG("desc->value :%s[end]\n",desc->value);
 204
 205                         if (!desc->value) {
 206                                 ERR("Failed to allocate buffer for the value\n");
 207                                 free(grp->name);
 208                                 delete grp;
 209                                 free(desc->name);
 210                                 delete desc;
 211                                 fclose(fp);
 212                                 return false;
 213                         }
 214
 215                         if (grp->tail) {
 216                                 desc->link(clist::AFTER, grp->tail);
 217                                 grp->tail = desc;
 218                         } else {
 219                                 grp->head = grp->tail = desc;
 220                         }
 221
 222                         grp->attr_cnt ++;
 223                         continue;
 224                 }
 225         }
 226
 227         if (m_tail != grp) {
 228                 if (m_tail && grp != NULL) {
 229                         grp->link(clist::AFTER, m_tail);
 230                         m_tail = grp;
 231                 } else {
 232                         m_tail = m_head = grp;
 233                 }
 234         }
 235
 236         fclose(fp);
 237         return true;
 238 }
 239
 240 bool ccatalog::is_loaded(void)
 241 {
 242         return (m_head != NULL) ?  true : false ;
 243 }
 244
 245 bool ccatalog::unload(void)
 246 {
 247         group_t *grp;
 248         group_t *next_grp;
 249         desc_t *desc;
 250         desc_t *next_desc;
 251
 252         grp = m_head;
 253         while (grp) {
 254                 next_grp = (group_t*)grp->next();
 255                 desc = grp->head;
 256                 while (desc) {
 257                         next_desc = (desc_t*)desc->next();
 258                         free(desc->name);
 259                         free(desc->value);
 260                         delete desc;
 261                         desc = next_desc;
 262                 }
 263                 free(grp->name);
 264                 delete grp;
 265                 grp = next_grp;
 266         }
 267         m_head = NULL;
 268         m_tail = NULL;
 269         return true;
 270 }
 271
 272 char *ccatalog::value(char *group, char *name)
 273 {
 274         group_t *grp;
 275
 276         grp = m_head;
 277         while (grp) {
 278                 if (!strncmp(group, grp->name, strlen(grp->name))) {
 279                         break;
 280                 }
 281                 grp = (group_t*)grp->next();
 282         }
 283
 284         if (grp) {
 285                 desc_t *desc;
 286                 desc = grp->head;
 287
 288                 while (desc) {
 289                         if (!strncmp(name, desc->name, sizeof(desc->name))) {
 290                                 return desc->value;
 291                         }
 292                         desc = (desc_t*)desc->next();
 293                 }
 294         }
 295
 296         return NULL;
 297 }
 298
 299 char *ccatalog::value(char *group, char *name, int idx)
 300 {
 301         group_t *grp;
 302         grp = m_head;
 303         while (grp) {
 304                 if (!strcmp(group, grp->name)) {
 305                         break;
 306                 }
 307                 grp = (group_t*)grp->next();
 308         }
 309
 310         if (grp) {
 311                 register int i;
 312                 desc_t *desc;
 313                 desc = grp->head;
 314                 i = 0;
 315                 while (desc) {
 316                         if (!strcmp(name, desc->name)) {
 317                                 if (i == idx) {
 318                                         return desc->value;
 319                                 }
 320                                         i ++;
 321                         }
 322                         desc = (desc_t *)desc->next();
 323                 }
 324         }
 325
 326         return NULL;
 327 }
 328
 329 int ccatalog::count_of_values(char *group, char *name)
 330 {
 331         group_t *grp;
 332         register int count = 0;
 333         grp = m_head;
 334         while (grp) {
 335                 if (!strcmp(group, grp->name)) {
 336                         break;
 337                 }
 338                 grp = (group_t*)grp->next();
 339         }
 340
 341         if (grp) {
 342                 desc_t *desc;
 343                 desc = grp->head;
 344
 345                 while (desc) {
 346                         if (!strcmp(name, desc->name)) {
 347                                 count ++;
 348                         }
 349                         desc = (desc_t *)desc->next();
 350                 }
 351         }
 352         return count;
 353 }
 354
 355 void *ccatalog::iterate_init(void)
 356 {
 357         return (void*)m_head;
 358 }
 359
 360 void *ccatalog::iterate_next(void *handle)
 361 {
 362         group_t *grp = (group_t*)handle;
 363         return grp->next();
 364 }
 365
 366 void *ccatalog::iterate_prev(void *handle)
 367 {
 368         group_t *grp = (group_t*)handle;
 369         return grp->prev();
 370 }
 371
 372 char *ccatalog::iterate_get_name(void *handle)
 373 {
 374         group_t *grp = (group_t*)handle;
 375         return grp->name;
 376 }
 377 //! End of a file