probe_socket/da_socket.h

   1 /*
   2  *  DA probe
   3  *
   4  * Copyright (c) 2000 - 2013 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact:
   7  *
   8  * Hyunjong Park <phjwithyou.park@samsung.com>
   9  * Juyoung Kim <j0.kim@samsung.com>
  10  * Anastasia Lyupa <a.lyupa@samsung.com
  11  *
  12  * This library is free software; you can redistribute it and/or modify it under
  13  * the terms of the GNU Lesser General Public License as published by the
  14  * Free Software Foundation; either version 2.1 of the License, or (at your option)
  15  * any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful, but WITHOUT ANY
  18  * WARRANTY; without even the implied warranty of MERCHANTABILITY or
  19  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
  20  * License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * along with this library; if not, write to the Free Software Foundation, Inc., 51
  24  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  25  *
  26  * Contributors:
  27  * - S-Core Co., Ltd
  28  * - Samsung RnD Institute Russia
  29  *
  30  */
  31
  32 #ifndef __DA_SOCKET_H__
  33 #define __DA_SOCKET_H__
  34
  35 #include "daprobe.h"
  36
  37 #define SOCKET_SEND_SIZE 256;
  38 #define NO_DESTINATIONINFO (NULL)
  39 #define POST_PROBEBLOCK_MIDDLE_LIBC_SOCK(OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE, DESTINATIONINFO )                              \
  40         do {                                                    \
  41                 BUF_PTR = pack_int64(BUF_PTR, (uintptr_t)OBJECTPTR);            \
  42                 BUF_PTR = pack_int64(BUF_PTR, FDVALUE);         \
  43                 BUF_PTR = pack_int32(BUF_PTR, APITYPE);         \
  44                 struct sockaddr *tmp_dest = ((struct sockaddr *)DESTINATIONINFO); \
  45                 if ( tmp_dest != NO_DESTINATIONINFO) { \
  46                         switch (tmp_dest->sa_family) { \
  47                                 case AF_INET:\
  48                                         BUF_PTR = pack_int32(BUF_PTR, ((struct sockaddr_in *)tmp_dest)->sin_addr.s_addr ); \
  49                                         BUF_PTR = pack_int32(BUF_PTR, ntohs(((struct sockaddr_in *)tmp_dest)->sin_port ) ); \
  50                                         break;\
  51                                 /*case AF_INET6:\
  52                                         BUF_PTR = pack_int32(BUF_PTR, ((struct sockaddr_in6 *)tmp_dest)->sin6_addr.s6_addr32 ); \
  53                                         BUF_PTR = pack_int32(BUF_PTR, ((struct sockaddr_in6 *)tmp_dest)->sin6_port ); \
  54                                         break;*/ \
  55                                 default:\
  56                                         BUF_PTR = pack_int32(BUF_PTR, (uint32_t) 0);    \
  57                                         BUF_PTR = pack_int32(BUF_PTR, (uint32_t) 0);    \
  58                                         break; \
  59                         } \
  60                 } else { \
  61                         BUF_PTR = pack_int32(BUF_PTR, (uint32_t) 0);    \
  62                         BUF_PTR = pack_int32(BUF_PTR, (uint32_t) 0);    \
  63                 }; \
  64                 BUF_PTR = pack_string(BUF_PTR, MESSAGE);                \
  65         } while (0)
  66
  67
  68 //lib Common Function
  69 #define AFTER_ORIGINAL_LIBC_SOCK(RVAL,OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE, DESTINATIONINFO, INPUTFORMAT, ...)        \
  70                 POST_PROBEBLOCK_BEGIN(LC_SOCKET, RTYPE, RVAL, INPUTFORMAT, __VA_ARGS__);                \
  71                 POST_PROBEBLOCK_MIDDLE_LIBC_SOCK(OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE, DESTINATIONINFO );                                                             \
  72                 POST_PROBEBLOCK_END();
  73
  74 //lib START Function
  75 #define AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(RVAL,OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE, DESTINATIONINFO, INPUTFORMAT, ...)        \
  76         POST_PROBEBLOCK_FUNC_START_BEGIN(LC_SOCKET, RTYPE, RVAL,        INPUTFORMAT, __VA_ARGS__);              \
  77         POST_PROBEBLOCK_MIDDLE_LIBC_SOCK(OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE, DESTINATIONINFO );                                                             \
  78         FLUSH_LOCAL_BUF();                                                                                                                                                                                      \
  79         PRE_PROBEBLOCK_END()
  80
  81 #define POST_PROBEBLOCK_FUNC_START_BEGIN(LCTYPE, RETTYPE, RETVALUE, INPUTFORMAT, ...)   \
  82                 newerrno = errno;                                                                                                               \
  83                         if(postBlockBegin(blockresult)) {                                                                               \
  84                                 PREPARE_LOCAL_BUF(); \
  85                                 PACK_COMMON_BEGIN(MSG_PROBE_NETWORK, vAPI_ID, INPUTFORMAT, __VA_ARGS__);\
  86                                 PACK_COMMON_END(RETVALUE, errno, blockresult)
  87
  88
  89 //lib END Function
  90 #define AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(RVAL, OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE, DESTINATIONINFO, INPUTFORMAT, ...) \
  91         POST_PROBEBLOCK_FUNC_END_BEGIN(LC_SOCKET, RTYPE, RVAL,  INPUTFORMAT, __VA_ARGS__);              \
  92         POST_PROBEBLOCK_MIDDLE_LIBC_SOCK(OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE, DESTINATIONINFO );                                                             \
  93         POST_PROBEBLOCK_END()
  94
  95 #define POST_PROBEBLOCK_FUNC_END_BEGIN(LCTYPE, RETTYPE, RETVALUE, INPUTFORMAT, ...)     \
  96         newerrno = errno;                                                                                                               \
  97         if(postBlockBegin(blockresult)) {                                                                               \
  98                 setProbePoint(&probeInfo);                                                                              \
  99                 PREPARE_LOCAL_BUF(); \
 100                 PACK_COMMON_BEGIN(MSG_PROBE_NETWORK, vAPI_ID, INPUTFORMAT, __VA_ARGS__);\
 101                 PACK_COMMON_END(RETVALUE, errno, blockresult)
 102
 103 #define BEFORE_ORIGINAL_TIZEN_NET(FUNCNAME, FUNCTIONPOINTER)    \
 104                 DECLARE_VARIABLE_STANDARD_OSP_NET(FUNCNAME);                                                            \
 105                 GET_REAL_FUNC_TIZEN(FUNCNAME, LIBOSP_NET,FUNCTIONPOINTER); \
 106                 PRE_PROBEBLOCK()
 107
 108 #define DECLARE_VARIABLE_STANDARD_OSP_NET(FUNCNAME)             \
 109                 probeInfo_t probeInfo;                          \
 110                 hostinfo_t hostinfo;                            \
 111                 int blockresult;                                \
 112                 bool bfiltering = true;                         \
 113                 int olderrno = 0, newerrno = 0;                 \
 114                 int32_t __attribute__((unused)) vAPI_ID = API_ID_ ## FUNCNAME /* FUNCID FIXME bad way*/; \
 115                 hostinfo.ip = 0;                                \
 116                 hostinfo.port = 0
 117
 118 #define POST_PROBEBLOCK_MIDDLE_TIZEN_SOCK(OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE, DESTINATIONINFO )                             \
 119         do {                                                                    \
 120                 BUF_PTR = pack_int64(BUF_PTR, (uintptr_t)OBJECTPTR);            \
 121                 BUF_PTR = pack_int64(BUF_PTR, FDVALUE);                         \
 122                 BUF_PTR = pack_int32(BUF_PTR, APITYPE);                         \
 123                 BUF_PTR = pack_int32(BUF_PTR, DESTINATIONINFO.ip);              \
 124                 BUF_PTR = pack_int32(BUF_PTR, DESTINATIONINFO.port);            \
 125                 BUF_PTR = pack_string(BUF_PTR, MESSAGE);                        \
 126         } while (0)
 127
 128
 129 //TIZEN
 130 #define CALL_ORIGINAL_TIZEN_NET(FUNCNAME, FUNCTIONPOINTER)      \
 131                 GET_REAL_FUNC_TIZEN(FUNCNAME, LIBOSP_NET,FUNCTIONPOINTER)
 132
 133
 134 //Tizen Common Function
 135 #define AFTER_ORIGINAL_TIZEN_SOCK(APINAME, RTYPE, RVAL,OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE, DESTINATIONINFO, INPUTFORMAT, ...)       \
 136         POST_PROBEBLOCK_TIZEN_BEGIN(APINAME, LC_SOCKET, RTYPE, RVAL,    INPUTFORMAT, __VA_ARGS__);              \
 137         POST_PROBEBLOCK_MIDDLE_TIZEN_SOCK(OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE, DESTINATIONINFO );                                                            \
 138         POST_PROBEBLOCK_END()
 139
 140 // Tizen Start Function
 141 #define AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_START(APINAME,RTYPE, RVAL,OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE, DESTINATIONINFO, INPUTFORMAT, ...)        \
 142         POST_PROBEBLOCK_TIZEN_FUNC_START_BEGIN(APINAME,LC_SOCKET, RTYPE, RVAL,  INPUTFORMAT, __VA_ARGS__);              \
 143         POST_PROBEBLOCK_MIDDLE_TIZEN_SOCK(OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE,DESTINATIONINFO );                                                             \
 144         PRE_PROBEBLOCK_END();
 145
 146 //Tizen END Function
 147 #define AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_END(APINAME,RTYPE, RVAL,OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE, DESTINATIONINFO, INPUTFORMAT, ...)  \
 148         POST_PROBEBLOCK_TIZEN_FUNC_END_BEGIN(APINAME,LC_SOCKET, RTYPE, RVAL,    INPUTFORMAT, __VA_ARGS__);              \
 149         POST_PROBEBLOCK_MIDDLE_TIZEN_SOCK(OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE,DESTINATIONINFO );                                                             \
 150         POST_PROBEBLOCK_END()
 151
 152 #define POST_PROBEBLOCK_TIZEN_BEGIN(APINAME, LCTYPE, RETTYPE, RETVALUE, INPUTFORMAT, ...)       \
 153         if(postBlockBegin(blockresult)) {                                                                               \
 154                 PREPARE_LOCAL_BUF(); \
 155                 PACK_COMMON_BEGIN(MSG_PROBE_NETWORK, vAPI_ID, INPUTFORMAT, __VA_ARGS__);\
 156                 PACK_COMMON_END(RETVALUE, errno, blockresult)
 157
 158 #define APPEND_NETWORK_LOG_BASIC(LCTYPE, APINAME)                                                               \
 159         log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",       \
 160                         LCTYPE, probeInfo.eventIndex, APINAME,                          \
 161                         probeInfo.currentTime, probeInfo.pID, probeInfo.tID)
 162
 163 #define POST_PROBEBLOCK_TIZEN_FUNC_START_BEGIN(APINAME, LCTYPE, RETTYPE, RETVALUE, INPUTFORMAT, ...)    \
 164                         if(postBlockBegin(blockresult)) {                                                                               \
 165                                 PREPARE_LOCAL_BUF(); \
 166                                 PACK_COMMON_BEGIN(MSG_PROBE_NETWORK, vAPI_ID, INPUTFORMAT, __VA_ARGS__);\
 167                                 PACK_COMMON_END(RETVALUE, errno, blockresult)
 168
 169 #define POST_PROBEBLOCK_TIZEN_FUNC_END_BEGIN(APINAME, LCTYPE, RETTYPE, RETVALUE, INPUTFORMAT, ...)      \
 170         if(postBlockBegin(blockresult)) {                                                                               \
 171                 setProbePoint(&probeInfo);                                                                              \
 172                 PREPARE_LOCAL_BUF(); \
 173                 PACK_COMMON_BEGIN(MSG_PROBE_NETWORK, vAPI_ID, INPUTFORMAT, __VA_ARGS__);\
 174                 PACK_COMMON_END(RETVALUE, errno, blockresult)
 175
 176 #define APPEND_LOG_TIZEN_RESULT(RETTYPE, RETVALUE)                                                      \
 177         __appendTypeLog(&log, 4, NULL, RETTYPE, RETVALUE, VT_INT, 0,            \
 178                         VT_INT, newerrno, VT_INT, blockresult)
 179
 180 #define BEFORE_ORIGINAL_SOCK(FUNCNAME, LIBNAME) \
 181         DECLARE_VARIABLE_STANDARD;      \
 182         int32_t __attribute__((unused)) vAPI_ID = API_ID_ ## FUNCNAME; \
 183         GET_REAL_FUNC(FUNCNAME, LIBNAME);               \
 184         PRE_PROBEBLOCK()
 185
 186 #endif // __DA_SOCKET_H__