src/s_common.c

   1 /**\r
   2  * tel-plugin-samsung\r
   3  *\r
   4  * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved\r
   5  *\r
   6  * Contact: Ja-young Gu <jygu@samsung.com>\r
   7  *\r
   8  * PROPRIETARY/CONFIDENTIAL\r
   9  *\r
  10  * This software is the confidential and proprietary information of SAMSUNG ELECTRONICS ("Confidential Information").\r
  11  * You shall not disclose such Confidential Information and shall\r
  12  * use it only in accordance with the terms of the license agreement you entered into with SAMSUNG ELECTRONICS.\r
  13  * SAMSUNG make no representations or warranties about the suitability\r
  14  * of the software, either express or implied, including but not\r
  15  * limited to the implied warranties of merchantability, fitness for a particular purpose, or non-infringement.\r
  16  * SAMSUNG shall not be liable for any damages suffered by licensee as\r
  17  * a result of using, modifying or distributing this software or its derivatives.\r
  18  */\r
  19 \r
  20 #include <stdio.h>\r
  21 #include <string.h>\r
  22 #include <stdlib.h>\r
  23 \r
  24 #include <glib.h>\r
  25 \r
  26 \r
  27 #include "s_common.h"\r
  28 \r
  29 #include <plugin.h>\r
  30 \r
  31 #undef  MAX\r
  32 #define MAX(a, b)  (((a) > (b)) ? (a) : (b))\r
  33 \r
  34 #undef  MIN\r
  35 #define MIN(a, b)  (((a) < (b)) ? (a) : (b))\r
  36 \r
  37 #define bitsize(type) (sizeof(type) * 8)\r
  38 \r
  39 #define copymask(type) ((0xffffffff) >> (32 - bitsize(type)))\r
  40 \r
  41 #define MASK(width, offset, data) \\r
  42    (((width) == bitsize(data)) ? (data) :   \\r
  43    ((((copymask(data) << (bitsize(data) - ((width) % bitsize(data)))) & copymask(data)) >>  (offset)) & (data))) \\r
  44 \r
  45 \r
  46 #define MASK_AND_SHIFT(width, offset, shift, data)  \\r
  47                   ((((signed) (shift)) < 0) ?       \\r
  48                     MASK((width), (offset), (data)) << -(shift) :  \\r
  49                     MASK((width), (offset), (data)) >>  (((unsigned) (shift)))) \\r
  50 \r
  51 char _util_unpackb(const char *src, int pos, int len);\r
  52 char _util_convert_byte_hexChar (char val);\r
  53 gboolean util_byte_to_hex(const char *byte_pdu, char *hex_pdu, int num_bytes);\r
  54 \r
  55 void util_hex_dump(char *pad, int size, const void *data)\r
  56 {\r
  57         char buf[255] = {0, };\r
  58         char hex[4] = {0, };\r
  59         int i;\r
  60         unsigned char *p;\r
  61 \r
  62         if (size <= 0) {\r
  63                 msg("%sno data", pad);\r
  64                 return;\r
  65         }\r
  66 \r
  67         p = (unsigned char *)data;\r
  68 \r
  69         snprintf(buf, 255, "%s%04X: ", pad, 0);\r
  70         for (i = 0; i<size; i++) {\r
  71                 snprintf(hex, 4, "%02X ", p[i]);\r
  72                 strcat(buf, hex);\r
  73 \r
  74                 if ((i + 1) % 8 == 0) {\r
  75                         if ((i + 1) % 16 == 0) {\r
  76                                 msg("%s", buf);\r
  77                                 memset(buf, 0, 255);\r
  78                                 snprintf(buf, 255, "%s%04X: ", pad, i + 1);\r
  79                         }\r
  80                         else {\r
  81                                 strcat(buf, "  ");\r
  82                         }\r
  83                 }\r
  84         }\r
  85 \r
  86         msg("%s", buf);\r
  87 }\r
  88 \r
  89 void hook_hex_dump(enum direction_e d, int size, const void *data)\r
  90 {\r
  91         msg("=== TX data DUMP =====");\r
  92         util_hex_dump("          ", size, data);\r
  93         msg("=== TX data DUMP =====");\r
  94 \r
  95 }\r
  96 \r
  97 unsigned int util_assign_message_sequence_id(TcorePlugin *p)\r
  98 {\r
  99         struct global_data *gd;\r
 100 \r
 101         if (!p) {\r
 102                 dbg("plugin is NULL");\r
 103                 return -1;\r
 104         }\r
 105 \r
 106         gd = tcore_plugin_ref_user_data(p);\r
 107         if (!gd) {\r
 108                 dbg("global data is NULL");\r
 109                 return -1;\r
 110         }\r
 111 \r
 112         if (gd->msg_auto_id_current == 0) {\r
 113                 gd->msg_auto_id_current = gd->msg_auto_id_start;\r
 114                 dbg("pending_auto_id_current is 0, reset to start");\r
 115         }\r
 116         else if (gd->msg_auto_id_current >= gd->msg_auto_id_end) {\r
 117                 gd->msg_auto_id_current = gd->msg_auto_id_start;\r
 118                 dbg("pending_auto_id_current is over, reset to start");\r
 119         }\r
 120         else {\r
 121                 gd->msg_auto_id_current++;\r
 122         }\r
 123 \r
 124         dbg("message_sequence_id = %d", gd->msg_auto_id_current);\r
 125 \r
 126         return gd->msg_auto_id_current;\r
 127 }\r
 128 \r
 129 gboolean util_add_waiting_job(GQueue *queue, unsigned int id, UserRequest *ur)\r
 130 {\r
 131         struct work_queue_data *wqd;\r
 132 \r
 133         if (!queue)\r
 134                 return FALSE;\r
 135 \r
 136         wqd = calloc(sizeof(struct work_queue_data), 1);\r
 137         if (!wqd)\r
 138                 return FALSE;\r
 139 \r
 140         wqd->id = id;\r
 141         wqd->ur = tcore_user_request_ref(ur);\r
 142         g_queue_push_tail(queue, wqd);\r
 143 \r
 144         dbg("id = %d, ur = 0x%x", wqd->id, wqd->ur);\r
 145         return TRUE;\r
 146 }\r
 147 \r
 148 UserRequest *util_pop_waiting_job(GQueue *queue, unsigned int id)\r
 149 {\r
 150         int i = 0;\r
 151         UserRequest *ur;\r
 152         struct work_queue_data *wqd;\r
 153 \r
 154         if (!queue)\r
 155                 return NULL;\r
 156 \r
 157 \r
 158         dbg("before waiting job count: %d", g_queue_get_length(queue));\r
 159 \r
 160         do {\r
 161                 wqd = g_queue_peek_nth(queue, i);\r
 162                 if (!wqd)\r
 163                         return NULL;\r
 164 \r
 165                 if (wqd->id == id) {\r
 166                         wqd = g_queue_pop_nth(queue, i);\r
 167                         break;\r
 168                 }\r
 169 \r
 170                 i++;\r
 171         } while (wqd != NULL);\r
 172 \r
 173         dbg("after  waiting job count: %d", g_queue_get_length(queue));\r
 174 \r
 175         if (!wqd)\r
 176                 return NULL;\r
 177 \r
 178         ur = wqd->ur;\r
 179         free(wqd);\r
 180 \r
 181         return ur;\r
 182 }\r
 183 \r
 184 unsigned char util_hexCharToInt(char c)\r
 185 {\r
 186     if (c >= '0' && c <= '9')\r
 187         return (c - '0');\r
 188     else if (c >= 'A' && c <= 'F')\r
 189         return (c - 'A' + 10);\r
 190     else if (c >= 'a' && c <= 'f')\r
 191         return (c - 'a' + 10);\r
 192     else\r
 193     {\r
 194         dbg("invalid charater!!");\r
 195         return -1;\r
 196     }\r
 197 }\r
 198 \r
 199 char * util_hexStringToBytes(char * s)\r
 200 {\r
 201     char * ret;\r
 202         int i;\r
 203         int sz;\r
 204 \r
 205         if (s == NULL)\r
 206                 return NULL;\r
 207 \r
 208         sz = strlen(s);\r
 209 \r
 210         ret = calloc((sz/2)+1, 1);\r
 211 \r
 212         dbg("Convert String to Binary!!");\r
 213 \r
 214         for (i = 0; i < sz; i += 2) {\r
 215                 ret[i / 2] = (char) ((util_hexCharToInt(s[i]) << 4) | util_hexCharToInt(s[i + 1]));\r
 216                 dbg("[%02x]", ret[i/2]);\r
 217     }\r
 218 \r
 219     return ret;\r
 220 }\r
 221 \r
 222 char _util_unpackb(const char *src, int pos, int len)\r
 223 {\r
 224         char result = 0;\r
 225         int rshift = 0;\r
 226 \r
 227         src += pos/8;\r
 228         pos %= 8;\r
 229 \r
 230         rshift = MAX( 8 - (pos + len), 0);\r
 231 \r
 232         if ( rshift > 0 ) {\r
 233 \r
 234          result = MASK_AND_SHIFT(len, pos, rshift, *src);\r
 235 \r
 236         } else {\r
 237 \r
 238          result = MASK(8-pos, pos, *src);\r
 239          src++;\r
 240          len -= 8 - pos;\r
 241 \r
 242           if ( len > 0 ) result = ( result<<len ) | (*src >> (8-len));  // if any bits left\r
 243         }\r
 244 \r
 245         return result;\r
 246 }\r
 247 \r
 248 char _util_convert_byte_hexChar (char val)\r
 249 {\r
 250         char hex_char;\r
 251 \r
 252         if (val <= 9)\r
 253         {\r
 254                 hex_char = (char)(val+'0');\r
 255         }\r
 256         else if (val >= 10 && val <= 15)\r
 257         {\r
 258                 hex_char = (char)(val-10+'A');\r
 259         }\r
 260         else\r
 261         {\r
 262                 hex_char = '0';\r
 263         }\r
 264 \r
 265         return (hex_char);\r
 266 }\r
 267 \r
 268 gboolean util_byte_to_hex(const char *byte_pdu, char *hex_pdu, int num_bytes)\r
 269 {\r
 270         int i;\r
 271         char nibble;\r
 272         int buf_pos = 0;\r
 273 \r
 274         for (i=0; i<num_bytes*2; i++)\r
 275         {\r
 276                 nibble = _util_unpackb(byte_pdu,buf_pos,4);\r
 277                 buf_pos += 4;\r
 278                 hex_pdu[i] = _util_convert_byte_hexChar(nibble);\r
 279         }\r
 280 \r
 281         return TRUE;\r
 282 }\r