return to + len;
}
+static char __attribute__((used)) *pack_bin(char *to, const char *from,
+ uint32_t len)
+{
+ memcpy(to, from, len);
+ return to + len;
+}
+
static inline char *pack_double(char *to, double val)
{
*(double *)to = val;
#define MSG_HDR_LEN 20
#define FLUSH_LOCAL_BUF() \
*(uint32_t *)(msg_buf + MSG_LEN_OFFSET) = (p - msg_buf) - MSG_HDR_LEN; \
- send(gTraceInfo.socket.daemonSock, msg_buf, (p - msg_buf), 0);
+ send(gTraceInfo.socket.daemonSock, msg_buf, (p - msg_buf), 0)
// =========================== post block macro ===========================
// ========================= print log =====================================
#define PRINTMSG(msg) printLogStr(msg, MSG_MSG)
+#define INIT_INFO \
+ info.host_ip = 0; \
+ info.host_port = 0; \
+ info.msg_total_size = 0; \
+ info.msg_pack_size = 0; \
+ info.sock = NULL; \
+ info.msg_buf = (char *)""
+
+typedef struct {
+ uint32_t host_port;
+ uint32_t host_ip;
+ struct sockaddr *sock;
+
+ uint64_t msg_total_size;
+ uint32_t msg_pack_size;
+ char *msg_buf;
+
+} info_t;
+
// =========================== declare variables ===========================
// local variable is faster than heap allocated variable
// array variable initialization with declare is expensive than memset
if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) { \
setProbePoint(&probeInfo)
-#define PRE_PROBEBLOCK_END() \
- preBlockEnd(); \
- } \
- olderrno = errno; \
+#define PRE_PROBEBLOCK_END() \
+ preBlockEnd(); \
+ } \
+ olderrno = errno; \
errno = 0
#define PRE_PROBEBLOCK() \
extern "C" {
#endif
-typedef struct {
- uint32_t port;
- uint32_t ip;
-} hostinfo_t;
#define GET_REAL_FUNC_TIZEN(FUNCNAME, LIBNAME, FUNCTIONPOINTER) \
do { \
#include "daprobe.h"
-#define SOCKET_SEND_SIZE 256;
-#define NO_DESTINATIONINFO (NULL)
-#define POST_PROBEBLOCK_MIDDLE_LIBC_SOCK(OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE, DESTINATIONINFO ) \
+
+#define SOCKET_SEND_SIZE 1024
+#define NO_TOTAL_INFO (NULL)
+#define POST_PROBEBLOCK_MIDDLE_LIBC_SOCK(OBJECTPTR, FDVALUE, APITYPE, TOTAL_INFO) \
do { \
BUF_PTR = pack_int64(BUF_PTR, (uintptr_t)OBJECTPTR); \
BUF_PTR = pack_int64(BUF_PTR, FDVALUE); \
BUF_PTR = pack_int32(BUF_PTR, APITYPE); \
- struct sockaddr *tmp_dest = ((struct sockaddr *)DESTINATIONINFO); \
- if ( tmp_dest != NO_DESTINATIONINFO) { \
+ struct sockaddr *tmp_dest = ((struct sockaddr *)TOTAL_INFO.sock); \
+ if ( tmp_dest != NO_TOTAL_INFO) { \
switch (tmp_dest->sa_family) { \
case AF_INET:\
BUF_PTR = pack_int32(BUF_PTR, ((struct sockaddr_in *)tmp_dest)->sin_addr.s_addr ); \
BUF_PTR = pack_int32(BUF_PTR, (uint32_t) 0); \
BUF_PTR = pack_int32(BUF_PTR, (uint32_t) 0); \
}; \
- BUF_PTR = pack_string(BUF_PTR, MESSAGE); \
+ BUF_PTR = pack_int64(BUF_PTR, TOTAL_INFO.msg_total_size); \
+ BUF_PTR = pack_bin(BUF_PTR, TOTAL_INFO.msg_buf, TOTAL_INFO.msg_pack_size); \
} while (0)
//lib Common Function
-#define AFTER_ORIGINAL_LIBC_SOCK(RVAL,OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE, DESTINATIONINFO, INPUTFORMAT, ...) \
+#define AFTER_ORIGINAL_LIBC_SOCK(RVAL,OBJECTPTR, FDVALUE, APITYPE, TOTAL_INFO, INPUTFORMAT, ...) \
POST_PROBEBLOCK_BEGIN(LC_SOCKET, RTYPE, RVAL, INPUTFORMAT, __VA_ARGS__); \
- POST_PROBEBLOCK_MIDDLE_LIBC_SOCK(OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE, DESTINATIONINFO ); \
+ POST_PROBEBLOCK_MIDDLE_LIBC_SOCK(OBJECTPTR, FDVALUE, APITYPE, TOTAL_INFO ); \
POST_PROBEBLOCK_END();
//lib START Function
-#define AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(RVAL,OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE, DESTINATIONINFO, INPUTFORMAT, ...) \
+#define AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(RVAL,OBJECTPTR, FDVALUE, APITYPE, TOTAL_INFO, INPUTFORMAT, ...) \
POST_PROBEBLOCK_FUNC_START_BEGIN(LC_SOCKET, RTYPE, RVAL, INPUTFORMAT, __VA_ARGS__); \
- POST_PROBEBLOCK_MIDDLE_LIBC_SOCK(OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE, DESTINATIONINFO ); \
+ POST_PROBEBLOCK_MIDDLE_LIBC_SOCK(OBJECTPTR, FDVALUE, APITYPE, TOTAL_INFO ); \
FLUSH_LOCAL_BUF(); \
PRE_PROBEBLOCK_END()
//lib END Function
-#define AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(RVAL, OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE, DESTINATIONINFO, INPUTFORMAT, ...) \
+#define AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(RVAL, OBJECTPTR, FDVALUE, APITYPE, TOTAL_INFO, INPUTFORMAT, ...) \
POST_PROBEBLOCK_FUNC_END_BEGIN(LC_SOCKET, RTYPE, RVAL, INPUTFORMAT, __VA_ARGS__); \
- POST_PROBEBLOCK_MIDDLE_LIBC_SOCK(OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE, DESTINATIONINFO ); \
+ POST_PROBEBLOCK_MIDDLE_LIBC_SOCK(OBJECTPTR, FDVALUE, APITYPE, TOTAL_INFO ); \
POST_PROBEBLOCK_END()
#define POST_PROBEBLOCK_FUNC_END_BEGIN(LCTYPE, RETTYPE, RETVALUE, INPUTFORMAT, ...) \
#define DECLARE_VARIABLE_STANDARD_OSP_NET(FUNCNAME) \
probeInfo_t probeInfo; \
- hostinfo_t hostinfo; \
+ info_t info; \
int blockresult; \
bool bfiltering = true; \
int olderrno = 0, newerrno = 0; \
int32_t __attribute__((unused)) vAPI_ID = API_ID_ ## FUNCNAME /* FUNCID FIXME bad way*/; \
- hostinfo.ip = 0; \
- hostinfo.port = 0
+ INIT_INFO
-#define POST_PROBEBLOCK_MIDDLE_TIZEN_SOCK(OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE, DESTINATIONINFO ) \
+#define POST_PROBEBLOCK_MIDDLE_TIZEN_SOCK(OBJECTPTR, FDVALUE, APITYPE, TOTAL_INFO ) \
do { \
BUF_PTR = pack_int64(BUF_PTR, (uintptr_t)OBJECTPTR); \
BUF_PTR = pack_int64(BUF_PTR, FDVALUE); \
BUF_PTR = pack_int32(BUF_PTR, APITYPE); \
- BUF_PTR = pack_int32(BUF_PTR, DESTINATIONINFO.ip); \
- BUF_PTR = pack_int32(BUF_PTR, DESTINATIONINFO.port); \
- BUF_PTR = pack_string(BUF_PTR, MESSAGE); \
+ BUF_PTR = pack_int32(BUF_PTR, TOTAL_INFO.host_ip); \
+ BUF_PTR = pack_int32(BUF_PTR, TOTAL_INFO.host_port); \
+ BUF_PTR = pack_int64(BUF_PTR, TOTAL_INFO.msg_total_size); \
+ BUF_PTR = pack_bin(BUF_PTR, TOTAL_INFO.msg_buf, TOTAL_INFO.msg_pack_size); \
} while (0)
//Tizen Common Function
-#define AFTER_ORIGINAL_TIZEN_SOCK(APINAME, RTYPE, RVAL,OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE, DESTINATIONINFO, INPUTFORMAT, ...) \
- POST_PROBEBLOCK_TIZEN_BEGIN(APINAME, LC_SOCKET, RTYPE, RVAL, INPUTFORMAT, __VA_ARGS__); \
- POST_PROBEBLOCK_MIDDLE_TIZEN_SOCK(OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE, DESTINATIONINFO ); \
+#define AFTER_ORIGINAL_TIZEN_SOCK(APINAME, RTYPE, RVAL, OBJECTPTR, FDVALUE, APITYPE, TOTAL_INFO, INPUTFORMAT, ...) \
+ POST_PROBEBLOCK_TIZEN_BEGIN(APINAME, LC_SOCKET, RTYPE, RVAL, INPUTFORMAT, __VA_ARGS__); \
+ POST_PROBEBLOCK_MIDDLE_TIZEN_SOCK(OBJECTPTR, FDVALUE, APITYPE, TOTAL_INFO ); \
POST_PROBEBLOCK_END()
// Tizen Start Function
-#define AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_START(APINAME,RTYPE, RVAL,OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE, DESTINATIONINFO, INPUTFORMAT, ...) \
- POST_PROBEBLOCK_TIZEN_FUNC_START_BEGIN(APINAME,LC_SOCKET, RTYPE, RVAL, INPUTFORMAT, __VA_ARGS__); \
- POST_PROBEBLOCK_MIDDLE_TIZEN_SOCK(OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE,DESTINATIONINFO ); \
+#define AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_START(APINAME, RTYPE, RVAL,OBJECTPTR, FDVALUE, APITYPE, TOTAL_INFO, INPUTFORMAT, ...) \
+ POST_PROBEBLOCK_TIZEN_FUNC_START_BEGIN(APINAME,LC_SOCKET, RTYPE, RVAL, INPUTFORMAT, __VA_ARGS__); \
+ POST_PROBEBLOCK_MIDDLE_TIZEN_SOCK(OBJECTPTR, FDVALUE, APITYPE, TOTAL_INFO ); \
+ FLUSH_LOCAL_BUF(); \
PRE_PROBEBLOCK_END();
//Tizen END Function
-#define AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_END(APINAME,RTYPE, RVAL,OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE, DESTINATIONINFO, INPUTFORMAT, ...) \
- POST_PROBEBLOCK_TIZEN_FUNC_END_BEGIN(APINAME,LC_SOCKET, RTYPE, RVAL, INPUTFORMAT, __VA_ARGS__); \
- POST_PROBEBLOCK_MIDDLE_TIZEN_SOCK(OBJECTPTR, FDVALUE, APITYPE, MESSAGE, BYTESIZE,DESTINATIONINFO ); \
+#define AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_END(APINAME,RTYPE, RVAL,OBJECTPTR, FDVALUE, APITYPE, TOTAL_INFO, INPUTFORMAT, ...) \
+ POST_PROBEBLOCK_TIZEN_FUNC_END_BEGIN(APINAME,LC_SOCKET, RTYPE, RVAL, INPUTFORMAT, __VA_ARGS__); \
+ POST_PROBEBLOCK_MIDDLE_TIZEN_SOCK(OBJECTPTR, FDVALUE, APITYPE, TOTAL_INFO ); \
POST_PROBEBLOCK_END()
#define POST_PROBEBLOCK_TIZEN_BEGIN(APINAME, LCTYPE, RETTYPE, RETVALUE, INPUTFORMAT, ...) \
__appendTypeLog(&log, 4, NULL, RETTYPE, RETVALUE, VT_INT, 0, \
VT_INT, newerrno, VT_INT, blockresult)
-#define BEFORE_ORIGINAL_SOCK(FUNCNAME, LIBNAME) \
- DECLARE_VARIABLE_STANDARD; \
- int32_t __attribute__((unused)) vAPI_ID = API_ID_ ## FUNCNAME; \
- GET_REAL_FUNC(FUNCNAME, LIBNAME); \
+#define BEFORE_ORIGINAL_SOCK(FUNCNAME, LIBNAME) \
+ DECLARE_VARIABLE_STANDARD; \
+ info_t info; \
+ INIT_INFO; \
+ int32_t __attribute__((unused)) vAPI_ID = API_ID_ ## FUNCNAME; \
+ GET_REAL_FUNC(FUNCNAME, LIBNAME); \
PRE_PROBEBLOCK()
#endif // __DA_SOCKET_H__
BEFORE_ORIGINAL_SOCK(socket, LIBC);
ret = socketp(domain, type, protocol);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, ret, SOCKET_API_FD_OPEN, "",
- 0, NO_DESTINATIONINFO, "ddd", domain, type, protocol);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, ret, SOCKET_API_FD_OPEN, info,
+ "ddd", domain, type, protocol);
return ret;
}
char* callAddress = getAddress(address);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, socket,
- SOCKET_API_ACCEPT_START, "", 0, address, "dsp",
+ SOCKET_API_ACCEPT_START, info, "dsp",
socket, callAddress, address_len);
ret = acceptp(socket, address, address_len);
+ info.sock = (struct sockaddr *)address;
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(ret, OBJ_DUMMY, socket,
- SOCKET_API_ACCEPT_END, "", 0, address, "dsp",
+ SOCKET_API_ACCEPT_END, info, "dsp",
socket, callAddress, address_len);
return ret;
char* callAddress = getAddress(addr);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, sockfd,
- SOCKET_API_ACCEPT_START, "", 0, addr, "dspd",
+ SOCKET_API_ACCEPT_START, info, "dspd",
sockfd, callAddress, addrlen, flags);
ret = accept4p(sockfd, addr, addrlen, flags);
+ info.sock = (struct sockaddr *)addr;
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(ret, OBJ_DUMMY, sockfd,
- SOCKET_API_ACCEPT_END, "", 0, addr, "dspd",
+ SOCKET_API_ACCEPT_END, info, "dspd",
sockfd, callAddress, addrlen, flags);
return ret;
BEFORE_ORIGINAL_SOCK(connect, LIBC);
ret = connectp(socket, address, address_len);
+ info.sock = (struct sockaddr *)address;
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, socket, SOCKET_API_CONNECT,
- "", 0, address, "dsd",
+ info, "dsd",
socket, getAddress(address), address_len);
return ret;
ret = shutdownp(socket, how);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, socket, SOCKET_API_FD_CLOSE,
- "", 0, NO_DESTINATIONINFO, "dd", socket, how);
+ info, "dd", socket, how);
return ret;
}
BEFORE_ORIGINAL_SOCK(bind, LIBC);
ret = bindp(socket, address, address_len);
+ info.sock = (struct sockaddr *)address;
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, socket, SOCKET_API_BIND, "",
- 0, address, "dsd",
- socket, getAddress(address), address_len);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, socket, SOCKET_API_BIND,
+ info, "dsd", socket, getAddress(address), address_len);
return ret;
}
BEFORE_ORIGINAL_SOCK(listen, LIBC);
ret = listenp(socket, backlog);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, socket, SOCKET_API_LISTEN, "",
- 0, NO_DESTINATIONINFO, "dd", socket, backlog);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, socket, SOCKET_API_LISTEN,
+ info, "dd", socket, backlog);
return ret;
}
ssize_t send(int socket, const void *message, size_t length, int flags) {
static ssize_t (*sendp)(int socket, const void *message, size_t length,
int flags);
- ssize_t sret;
+ ssize_t sret, result;
BEFORE_ORIGINAL_SOCK(send, LIBC);
- int* messagP = (int*) message;
+ char *messagP = (char *)message;
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, socket,
- SOCKET_API_SEND_START, "", 0, NO_DESTINATIONINFO, "dpdd",
+ SOCKET_API_SEND_START, info, "dpdd",
socket, messagP, length, flags);
sret = sendp(socket, message, length, flags);
-
- int sendMaxSize = SOCKET_SEND_SIZE;
- char* out = (char*) malloc(sendMaxSize + 5);
- if (sret <= 0) {
- out[0] = '\0';
- } else {
- memcpy(out, message, sendMaxSize + 5);
- if (sret > sendMaxSize + 5) {
- out[sendMaxSize] = '.';
- out[sendMaxSize + 1] = '.';
- out[sendMaxSize + 2] = '.';
- out[sendMaxSize + 3] = '\0';
- } else {
- out[sret] = '\0';
- }
- }
+ result = sret;
+ if (result < 0)
+ result = 0;
+ info.msg_total_size = result;
+ info.msg_pack_size = result>SOCKET_SEND_SIZE?SOCKET_SEND_SIZE:result;
+ info.msg_buf = messagP;
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(sret, OBJ_DUMMY, socket,
- SOCKET_API_SEND_END, out, sret, NO_DESTINATIONINFO, "dpdd",
+ SOCKET_API_SEND_END, info, "dpdd",
socket, messagP, length, flags);
- free(out);
return sret;
}
ssize_t recv(int socket, void *buffer, size_t length, int flags) {
static ssize_t (*recvp)(int socket, void *buffer, size_t length, int flags);
- ssize_t sret;
+ ssize_t sret, result;
BEFORE_ORIGINAL_SOCK(recv, LIBC);
- int* bufferP = (int*) buffer;
+ char *bufferP = (char *)buffer;
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, socket,
- SOCKET_API_RECV_START, "", 0, NO_DESTINATIONINFO, "dpdd",
+ SOCKET_API_RECV_START, info, "dpdd",
socket, bufferP, length, flags);
sret = recvp(socket, buffer, length, flags);
-
- int sendMaxSize = SOCKET_SEND_SIZE;
- char* out = (char*) malloc(sendMaxSize + 5);
- if (sret <= 0) {
- out[0] = '\0';
- } else {
- memcpy(out, buffer, sendMaxSize + 5);
- if (sret > sendMaxSize + 5) {
- out[sendMaxSize] = '.';
- out[sendMaxSize + 1] = '.';
- out[sendMaxSize + 2] = '.';
- out[sendMaxSize + 3] = '\0';
- } else {
- out[sret] = '\0';
- }
- }
+ result = sret;
+ if (result < 0)
+ result = 0;
+ info.msg_total_size = result;
+ info.msg_pack_size = result>SOCKET_SEND_SIZE?SOCKET_SEND_SIZE:result;
+ info.msg_buf = bufferP;
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(sret, OBJ_DUMMY, socket,
- SOCKET_API_RECV_END, out, sret, NO_DESTINATIONINFO, "dpdd",
+ SOCKET_API_RECV_END, info, "dpdd",
socket, bufferP, length, flags);
- free(out);
return sret;
}
const struct sockaddr *dest_addr, socklen_t dest_len) {
static ssize_t (*sendtop)(int socket, const void *message, size_t length,
int flags, const struct sockaddr *dest_addr, socklen_t dest_len);
- ssize_t sret;
+ ssize_t sret, result;
BEFORE_ORIGINAL_SOCK(sendto, LIBC);
- int* bufferP = (int*) message;
+ char *bufferP = (char *)message;
+ info.sock = (struct sockaddr *) dest_addr;
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, socket,
- SOCKET_API_SEND_START, "", 0, dest_addr, "dpddpd",
+ SOCKET_API_SEND_START, info, "dpddpd",
socket, bufferP, length, flags, dest_addr, dest_len);
sret = sendtop(socket, message, length, flags, dest_addr, dest_len);
-
- int sendMaxSize = SOCKET_SEND_SIZE;
- char* out = (char*) malloc(sendMaxSize + 5);
- if (sret <= 0) {
- out[0] = '\0';
- } else {
- memcpy(out, message, sendMaxSize + 5);
- if (sret > sendMaxSize + 5) {
- out[sendMaxSize] = '.';
- out[sendMaxSize + 1] = '.';
- out[sendMaxSize + 2] = '.';
- out[sendMaxSize + 3] = '\0';
- } else {
- out[sret] = '\0';
- }
- }
+ result = sret;
+ if (result < 0)
+ result = 0;
+ info.msg_total_size = result;
+ info.msg_pack_size = result>SOCKET_SEND_SIZE?SOCKET_SEND_SIZE:result;
+ info.msg_buf = bufferP;
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(sret, OBJ_DUMMY, socket,
- SOCKET_API_SEND_END, out, sret, NO_DESTINATIONINFO, "dpddpd",
+ SOCKET_API_SEND_END, info, "dpddpd",
socket, bufferP, length, flags, dest_addr, dest_len);
- free(out);
return sret;
}
struct sockaddr *address, socklen_t *address_len) {
static ssize_t (*recvfromp)(int socket, void *buffer, size_t length,
int flags, struct sockaddr *address, socklen_t *address_len);
- ssize_t sret;
+ ssize_t sret, result;
BEFORE_ORIGINAL_SOCK(recvfrom, LIBC);
- int* bufferP = (int*) buffer;
+ char *bufferP = (char *)buffer;
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, socket,
- SOCKET_API_RECV_START, "", 0, NO_DESTINATIONINFO, "dpddpp",
+ SOCKET_API_RECV_START, info, "dpddpp",
socket, bufferP, length, flags, address, address_len);
sret = recvfromp(socket, buffer, length, flags, address, address_len);
+ info.sock = (struct sockaddr *)address;
- int sendMaxSize = SOCKET_SEND_SIZE;
- char* out = (char*) malloc(sendMaxSize + 5);
- if (sret <= 0) {
- out[0] = '\0';
- } else {
- memcpy(out, buffer, sendMaxSize + 5);
- if (sret > sendMaxSize + 5) {
- out[sendMaxSize] = '.';
- out[sendMaxSize + 1] = '.';
- out[sendMaxSize + 2] = '.';
- out[sendMaxSize + 3] = '\0';
- } else {
- out[sret] = '\0';
- }
- }
+ result = sret;
+ if (result < 0)
+ result = 0;
+ info.msg_total_size = result;
+ info.msg_pack_size = result>SOCKET_SEND_SIZE?SOCKET_SEND_SIZE:result;
+ info.msg_buf = bufferP;
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(sret, OBJ_DUMMY, socket,
- SOCKET_API_RECV_END, out, sret, NO_DESTINATIONINFO, "dpddpp",
+ SOCKET_API_RECV_END, info, "dpddpp",
socket, bufferP, length, flags, address, address_len);
- free(out);
return sret;
}
int* bufferP = (int*) message->msg_name;
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, socket,
- SOCKET_API_RECV_START, "", 0, NO_DESTINATIONINFO, "dpd",
+ SOCKET_API_RECV_START, info, "dpd",
socket, message, flags);
sret = recvmsgp(socket, message, flags);
}
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(sret, OBJ_DUMMY, socket,
- SOCKET_API_RECV_END, out, sret, NO_DESTINATIONINFO, "dpd",
+ SOCKET_API_RECV_END, info, "dpd",
socket, bufferP, flags);
free(out);
return sret;
int* bufferP = (int*) message->msg_name;
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, socket,
- SOCKET_API_SEND_START, "", 0, NO_DESTINATIONINFO, "dpd",
+ SOCKET_API_SEND_START, info, "dpd",
socket, message, flags);
sret = sendmsgp(socket, message, flags);
}
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(sret, OBJ_DUMMY, socket,
- SOCKET_API_SEND_END, out, sret, NO_DESTINATIONINFO, "dpd",
+ SOCKET_API_SEND_END, info, "dpd",
socket, bufferP, flags);
free(out);
return sret;
ret = getsockoptp(socket, level, option_name, option_value, option_len);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, socket, SOCKET_API_OTHER, "",
- 0, NO_DESTINATIONINFO, "dddpp",
- socket, level, option_name, option_value, option_len);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, socket, SOCKET_API_OTHER, info,
+ "dddpp", socket, level, option_name,
+ option_value, option_len);
return ret;
}
ret = setsockoptp(socket, level, option_name, option_value, option_len);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, socket, SOCKET_API_OTHER, "",
- 0, NO_DESTINATIONINFO, "dddpd",
- socket, level, option_name, option_value, option_len);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, socket, SOCKET_API_OTHER, info,
+ "dddpd", socket, level, option_name,
+ option_value, option_len);
return ret;
}
BEFORE_ORIGINAL_SOCK(getpeername, LIBC);
ret = getpeernamep(fd, addr, len);
+ info.sock = (struct sockaddr *)addr;
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, fd, SOCKET_API_OTHER, "", 0,
- getAddress(addr), "dsp", fd, getAddress(addr), len);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, fd, SOCKET_API_OTHER, info,
+ "dsp", fd, getAddress(addr), len);
return ret;
}
BEFORE_ORIGINAL_SOCK(getsockname, LIBC);
ret = getsocknamep(sockfd, addr, addrlen);
+ info.sock = (struct sockaddr *)addr;
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, sockfd, SOCKET_API_OTHER, "",
- 0, getAddress(addr), "dsp",
- sockfd, getAddress(addr), addrlen);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, sockfd, SOCKET_API_OTHER, info,
+ "dsp", sockfd, getAddress(addr), addrlen);
return ret;
}
ret = socketpairp(domain, type, protocol, socket_vector);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, socket_vector[0],
- SOCKET_API_FD_OPEN, "", 0, NO_DESTINATIONINFO, "ddddd",
+ SOCKET_API_FD_OPEN, info, "ddddd",
domain, type, protocol, socket_vector[0], socket_vector[1]);
return ret;
ret = sockatmarkp(__fd);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, __fd,
- SOCKET_API_OTHER, "", 0, NO_DESTINATIONINFO, "d", __fd);
+ SOCKET_API_OTHER, info, "d", __fd);
return ret;
}
ret = isfdtypep(__fd, __fdtype);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, __fd, SOCKET_API_OTHER, "", 0,
- NO_DESTINATIONINFO, "dd", __fd, __fdtype);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, __fd, SOCKET_API_OTHER, info,
+ "dd", __fd, __fdtype);
return ret;
}
BEFORE_ORIGINAL_SOCK(select, LIBC);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, 0,
- SOCKET_API_EVENT_START, "", 0, NO_DESTINATIONINFO, "dpppp",
+ SOCKET_API_EVENT_START, info, "dpppp",
nfds, readfds, writefds, exceptfds, timeout);
ret = selectp(nfds, readfds, writefds, exceptfds, timeout);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(ret, OBJ_DUMMY, 0,
- SOCKET_API_EVENT_END, "", 0, NO_DESTINATIONINFO, "dpppp",
+ SOCKET_API_EVENT_END, info, "dpppp",
nfds, readfds, writefds, exceptfds, timeout);
return ret;
BEFORE_ORIGINAL_SOCK(pselect, LIBC);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, 0,
- SOCKET_API_EVENT_START, "", 0, NO_DESTINATIONINFO, "dppppp",
+ SOCKET_API_EVENT_START, info, "dppppp",
nfds, readfds, writefds, exceptfds, ntimeout, sigmask);
ret = pselectp(nfds, readfds, writefds, exceptfds, ntimeout, sigmask);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(ret, OBJ_DUMMY, 0,
- SOCKET_API_EVENT_END, "", 0, NO_DESTINATIONINFO, "dppppp",
+ SOCKET_API_EVENT_END, info, "dppppp",
nfds, readfds, writefds, exceptfds, ntimeout, sigmask);
return ret;
BEFORE_ORIGINAL_SOCK(poll, LIBC);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, fds->fd,
- SOCKET_API_EVENT_START, "", 0, NO_DESTINATIONINFO, "pxd",
+ SOCKET_API_EVENT_START, info, "pxd",
fds, nfds, timeout);
ret = pollp(fds, nfds, timeout);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(ret, OBJ_DUMMY, fds->fd,
- SOCKET_API_EVENT_END, "", 0, NO_DESTINATIONINFO, "pxd", fds, nfds, timeout);
+ SOCKET_API_EVENT_END, info, "pxd", fds, nfds, timeout);
return ret;
}
BEFORE_ORIGINAL_SOCK(ppoll, LIBC);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, fds->fd,
- SOCKET_API_EVENT_START, "", 0, NO_DESTINATIONINFO, "pxpp",
+ SOCKET_API_EVENT_START, info, "pxpp",
fds, nfds, timeout_ts, sigmask);
ret = ppollp(fds, nfds, timeout_ts, sigmask);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(ret, OBJ_DUMMY, fds->fd,
- SOCKET_API_EVENT_END, "", 0, NO_DESTINATIONINFO, "pxpp",
+ SOCKET_API_EVENT_END, info, "pxpp",
fds, nfds, timeout_ts, sigmask);
return ret;
ret = epoll_createp(__size);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, ret, SOCKET_API_FD_OPEN, "",
- 0, NO_DESTINATIONINFO, "d", __size);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, ret, SOCKET_API_FD_OPEN, info,
+ "d", __size);
return ret;
}
ret = epoll_create1p(__flags);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, ret, SOCKET_API_FD_OPEN, "",
- 0, NO_DESTINATIONINFO, "d", __flags);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, ret, SOCKET_API_FD_OPEN, info,
+ "d", __flags);
return ret;
}
BEFORE_ORIGINAL_SOCK(epoll_wait, LIBC);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, __epfd,
- SOCKET_API_EVENT_START, "", 0, NO_DESTINATIONINFO, "dpdd",
+ SOCKET_API_EVENT_START, info, "dpdd",
__epfd, __events, __maxevents, __timeout);
ret = epoll_waitp(__epfd, __events, __maxevents, __timeout);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(ret, OBJ_DUMMY, __epfd,
- SOCKET_API_EVENT_END, "", 0, NO_DESTINATIONINFO, "dpdd",
+ SOCKET_API_EVENT_END, info, "dpdd",
__epfd, __events, __maxevents, __timeout);
return ret;
BEFORE_ORIGINAL_SOCK(epoll_pwait, LIBC);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, __epfd,
- SOCKET_API_EVENT_START, "", 0, NO_DESTINATIONINFO, "dpdd %p",
+ SOCKET_API_EVENT_START, info, "dpdd %p",
__epfd, __events, __maxevents, __timeout, __ss);
ret = epoll_pwaitp(__epfd, __events, __maxevents, __timeout, __ss);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(ret, OBJ_DUMMY, __epfd,
- SOCKET_API_EVENT_END, "", 0, NO_DESTINATIONINFO, "dpdd %p",
+ SOCKET_API_EVENT_END, info, "dpdd %p",
__epfd, __events, __maxevents, __timeout, __ss);
return ret;
ret = epoll_ctlp(__epfd, __op, __fd, __event);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, __fd, SOCKET_API_OTHER, "", 0,
- NO_DESTINATIONINFO, "dddp", __epfd, __op, __fd, __event);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, __fd, SOCKET_API_OTHER, info,
+ "dddp", __epfd, __op, __fd, __event);
return ret;
}
uret = htonlp(hostlong);
AFTER_ORIGINAL_LIBC_SOCK(VT_UINT32_T, uret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- NO_DESTINATIONINFO, "", "d", hostlong);
+ info "d", hostlong);
return uret;
}
uret = htonsp(hostshort);
AFTER_ORIGINAL_LIBC_SOCK(VT_UINT16_T, uret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- NO_DESTINATIONINFO, "", "d", hostshort);
+ info "d", hostshort);
return uret;
}
ret = inet_atonp(cp, inp);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "pp", cp, inp);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "pp", cp, inp);
return ret;
}
iret = inet_addrp(cp);
- AFTER_ORIGINAL_LIBC_SOCK(iret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "p", cp);
+ AFTER_ORIGINAL_LIBC_SOCK(iret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "p", cp);
return iret;
}
iret = inet_networkp(cp);
- AFTER_ORIGINAL_LIBC_SOCK(iret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "p", cp);
+ AFTER_ORIGINAL_LIBC_SOCK(iret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "p", cp);
return iret;
}
sret = inet_ntoap(in);
- AFTER_ORIGINAL_LIBC_SOCK(sret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "d", in.s_addr);
+ AFTER_ORIGINAL_LIBC_SOCK(sret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "d", in.s_addr);
return sret;
}
uret = ntohlp(netlong);
AFTER_ORIGINAL_LIBC_SOCK(VT_UINT32_T, uret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- NO_DESTINATIONINFO, "", "d", netlong);
+ info "d", netlong);
return uret;
}
uret = ntohsp(netshort);
AFTER_ORIGINAL_LIBC_SOCK(VT_UINT16_T, uret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- NO_DESTINATIONINFO, "", "d", netshort);
+ info "d", netshort);
return uret;
}
iret = inet_lnaofp(in);
AFTER_ORIGINAL_LIBC_SOCK(VT_UINT32_T, iret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- NO_DESTINATIONINFO, "", "d", in.s_addr);
+ info "d", in.s_addr);
return iret;
}
iret = inet_netofp(in);
AFTER_ORIGINAL_LIBC_SOCK(VT_UINT32_T, iret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- NO_DESTINATIONINFO, "", "d", in.s_addr);
+ info "d", in.s_addr);
return iret;
}
cret = inet_ntopp(af, src, dst, size);
- AFTER_ORIGINAL_LIBC_SOCK(cret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "dppd", af, src, dst, size);
+ AFTER_ORIGINAL_LIBC_SOCK(cret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "dppd", af, src, dst, size);
return cret;
}
ret = inet_ptonp(af, src, dst);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "dpp", af, src, dst);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "dpp", af, src, dst);
return ret;
}
ret = getaddrinfop(node, service, hints, res);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "pppp", node, service, hints, res);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "pppp", node, service, hints, res);
return ret;
}
freeaddrinfop(res);
- AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "p", res);
+ AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "p", res);
}
const char *gai_strerror(int errcode) {
cret = gai_strerrorp(errcode);
- AFTER_ORIGINAL_LIBC_SOCK(cret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "d", errcode);
+ AFTER_ORIGINAL_LIBC_SOCK(cret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "d", errcode);
return cret;
}
ret = gai_suspendp(list, nitems, timeout);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "pdp", list, nitems, timeout);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "pdp", list, nitems, timeout);
return ret;
}
ret = gai_errorp(req);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "p", req);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "p", req);
return ret;
}
ret = gai_cancelp(req);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "p", req);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "p", req);
return ret;
}
ret = getaddrinfo_ap(mode, list, nitems, sevp);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "dpdp", mode, list, nitems, sevp);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "dpdp", mode, list, nitems, sevp);
return ret;
}
//AFTER_ORIGINAL_NOSOCK(FD_API_OTHER, "pd", name, len);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "pd", name, len);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "pd", name, len);
return ret;
}
ret = setdomainnamep(name, len);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "pd", name, len);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "pd", name, len);
return ret;
}
ret = gethostnamep(name, len);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "pd", name, len);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "pd", name, len);
return ret;
}
ret = sethostnamep(name, len);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "pd", name, len);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "pd", name, len);
return ret;
}
ret = getnameinfop(sa, salen, host, hostlen, serv, servlen, flags);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "pdpdpdd",
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "pdpdpdd",
sa, salen, host, hostlen, serv, servlen, flags);
return ret;
pret = gethostbynamep(name);
- AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "p", name);
+ AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "p", name);
return pret;
}
pret = gethostbyaddrp(addr, len, type);
- AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "pdd", addr, len, type);
+ AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "pdd", addr, len, type);
return pret;
}
sethostentp(stayopen);
- AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "d", stayopen);
+ AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "d", stayopen);
}
void endhostent(void) {
//AFTER_ORIGINAL_NOSOCK_RET(NULL, 0, FD_API_OTHER, "s", "");
- AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "s", "");
+ AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "s", "");
}
void herror(const char *s) {
herrorp(s);
- AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "p", s);
+ AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "p", s);
}
const char *hstrerror(int err) {
cret = hstrerrorp(err);
- AFTER_ORIGINAL_LIBC_SOCK(cret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "d", err);
+ AFTER_ORIGINAL_LIBC_SOCK(cret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "d", err);
return cret;
}
pret = gethostentp();
- AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "s", "");
+ AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "s", "");
return pret;
}
pret = gethostbyname2p(name, af);
- AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "pd", name, af);
+ AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "pd", name, af);
return pret;
}
ret = gethostent_rp(rret, buf, buflen, result, h_errnop);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "ppdpp", rret, buf, buflen, result, h_errnop);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "ppdpp", rret, buf, buflen, result, h_errnop);
return ret;
}
ret = gethostbyaddr_rp(addr, len, type, rret, buf, buflen, result,
h_errnop);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "pddppdpp",
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "pddppdpp",
addr, len, type, rret, buf, buflen, result, h_errnop);
return ret;
ret = gethostbyname_rp(name, rret, buf, buflen, result, h_errnop);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "pppdpp",
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "pppdpp",
name, rret, buf, buflen, result, h_errnop);
return ret;
ret = gethostbyname2_rp(name, af, rret, buf, buflen, result, h_errnop);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "pdppdpp",
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "pdppdpp",
name, af, rret, buf, buflen, result, h_errnop);
return ret;
pret = getservbynamep(name, proto);
- AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "pp", name, proto);
+ AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "pp", name, proto);
return pret;
}
setserventp(stayopen);
- AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "d", stayopen);
+ AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "d", stayopen);
}
void endservent(void) {
endserventp();
- AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "s", "");
+ AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "s", "");
}
struct servent *getservent(void) {
pret = getserventp();
- AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "s", "");
+ AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "s", "");
return pret;
}
pret = getservbyportp(port, proto);
- AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "dp", port, proto);
+ AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "dp", port, proto);
return pret;
}
ret = getservent_rp(result_buf, buf, buflen, result);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "ppdp", result_buf, buf, buflen, result);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "ppdp", result_buf, buf, buflen, result);
return ret;
}
ret = getservbyname_rp(name, proto, result_buf, buf, buflen, result);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "ppppdp",
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "ppppdp",
name, proto, result_buf, buf, buflen, result);
return ret;
ret = getservbyport_rp(port, proto, result_buf, buf, buflen, result);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "dpppdp",
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "dpppdp",
port, proto, result_buf, buf, buflen, result);
return ret;
pret = getnetentp();
- AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "s", "");
+ AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "s", "");
return pret;
}
pret = getnetbynamep(name);
- AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "p", name);
+ AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "p", name);
return pret;
}
pret = getnetbyaddrp(net, type);
- AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "dd", net, type);
+ AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "dd", net, type);
return pret;
}
setnetentp(stayopen);
- AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "d", stayopen);
+ AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "d", stayopen);
}
void endnetent(void) {
endnetentp();
- AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "s", "");
+ AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "s", "");
}
int getnetent_r(struct netent *result_buf, char *buf, size_t buflen,
ret = getnetent_rp(result_buf, buf, buflen, result, h_errnop);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "ppdpp",
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "ppdpp",
result_buf, buf, buflen, result, h_errnop);
return ret;
ret = getnetbyname_rp(name, result_buf, buf, buflen, result, h_errnop);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "pppdpp",
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "pppdpp",
name, result_buf, buf, buflen, result, h_errnop);
return ret;
ret = getnetbyaddr_rp(net, type, result_buf, buf, buflen, result, h_errnop);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "ddppdpp",
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "ddppdpp",
net, type, result_buf, buf, buflen, result, h_errnop);
return ret;
pret = getprotoentp();
- AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "s", "");
+ AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "s", "");
return pret;
}
pret = getprotobynamep(name);
- AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "p", name);
+ AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "p", name);
return pret;
}
pret = getprotobynumberp(proto);
- AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "d", proto);
+ AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "d", proto);
return pret;
}
setprotoentp(stayopen);
- AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "d", stayopen);
+ AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "d", stayopen);
}
void endprotoent(void) {
endprotoentp();
- AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "s", "");
+ AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "s", "");
}
int getprotoent_r(struct protoent *result_buf, char *buf, size_t buflen,
ret = getprotoent_rp(result_buf, buf, buflen, result);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "ppdp", result_buf, buf, buflen, result);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "ppdp", result_buf, buf, buflen, result);
return ret;
}
ret = getprotobyname_rp(name, result_buf, buf, buflen, result);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "pppdp", name, result_buf, buf, buflen, result);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "pppdp", name, result_buf, buf, buflen, result);
return ret;
}
ret = getprotobynumber_rp(proto, result_buf, buf, buflen, result);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "dppdp", proto, result_buf, buf, buflen, result);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "dppdp", proto, result_buf, buf, buflen, result);
return ret;
}
uret = if_nametoindexp(__ifname);
- AFTER_ORIGINAL_LIBC_SOCK(uret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "p", __ifname);
+ AFTER_ORIGINAL_LIBC_SOCK(uret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "p", __ifname);
return uret;
}
cret = if_indextonamep(__ifindex, __ifname);
- AFTER_ORIGINAL_LIBC_SOCK(cret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "dp", __ifindex, __ifname);
+ AFTER_ORIGINAL_LIBC_SOCK(cret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "dp", __ifindex, __ifname);
return cret;
}
pret = if_nameindexp();
- AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "s", "");
+ AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "s", "");
return pret;
}
if_freenameindexp(__ptr);
- AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "p", __ptr);
+ AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "p", __ptr);
}
int getifaddrs(struct ifaddrs **ifap) {
ret = getifaddrsp(ifap);
- AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "p", ifap);
+ AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
+ info, "p", ifap);
return ret;
}
freeifaddrsp(ifa);
- AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER, "",
- NO_DESTINATIONINFO, "p", ifa);
+ AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER, info,
+ "p", ifa);
}
//To do
strData.Append(*retVal);
char* out = new char[bufferSize];
WcharToChar(out, strData.GetPointer());
- int socketSendSize = SOCKET_SEND_SIZE;
- if (socketSendSize != 0 && socketSendSize < bufferSize) {
- out[socketSendSize + 1] = '.';
- out[socketSendSize + 2] = '.';
- out[socketSendSize + 3] = '.';
- out[socketSendSize + 4] = '\0';
- }
+
+ info.msg_buf = out;
+ info.msg_pack_size = bufferSize > SOCKET_SEND_SIZE ? SOCKET_SEND_SIZE : bufferSize;
+ info.msg_total_size = bufferSize;
AFTER_ORIGINAL_TIZEN_SOCK("HttpHeader::GetRawHeaderN", VT_NULL, NULL,
- (unsigned int)this, (unsigned int)this, HTTP_API_RESPONSE, out,
- retVal->GetLength(), hostinfo, "s", "void");
+ (unsigned int)this, (unsigned int)this,
+ HTTP_API_RESPONSE, info, "s", "void");
delete [] out;
return retVal;
}
AFTER_ORIGINAL_TIZEN_SOCK("HttpSession::Construct", VT_ULONG, retVal,
(unsigned int)this, (unsigned int)this, HTTP_API_SESSION_CONSTRUCT,
- "", 0, hostinfo, "dssxd",
+ info, "dssxd",
sessionMode, temp1, temp2, (unsigned int)&pCommonHeader, flag);
return retVal;
}
AFTER_ORIGINAL_TIZEN_SOCK("HttpSession::Construct", VT_ULONG, retVal,
(unsigned int)this, (unsigned int)this, HTTP_API_SESSION_CONSTRUCT,
- "", 0, hostinfo, "xdssxd",
+ info, "xdssxd",
(unsigned int)&netConnection, sessionMode, temp1, temp2, (unsigned int)&pCommonHeader, flag);
return retVal;
}
newerrno = 1;
AFTER_ORIGINAL_TIZEN_SOCK("HttpSession::OpenTransactionN", VT_PTR, retVal,
(unsigned int)this, (unsigned int)this, HTTP_API_TRANSACTION_OPEN,
- "", 0, hostinfo, "s", "void");
+ info, "s", "void");
return retVal;
}
newerrno = 1;
AFTER_ORIGINAL_TIZEN_SOCK("HttpSession::OpenTransactionN", VT_PTR, retVal,
(unsigned int)this, (unsigned int)this, HTTP_API_TRANSACTION_OPEN,
- "", 0, hostinfo, "x", (unsigned int)&auth);
+ info, "x", (unsigned int)&auth);
return retVal;
}
AFTER_ORIGINAL_TIZEN_SOCK("HttpSession::CancelTransaction", VT_ULONG,
retVal, (unsigned int)this, (unsigned int)this,
- HTTP_API_TRANSACTION_CLOSE, "", 0, hostinfo, "x",
+ HTTP_API_TRANSACTION_CLOSE, info, "x",
(unsigned int)&httpTransaction);
return retVal;
AFTER_ORIGINAL_TIZEN_SOCK("HttpSession::CloseTransaction", VT_ULONG, retVal,
(unsigned int)this, (unsigned int)this, HTTP_API_TRANSACTION_CLOSE,
- "", 0, hostinfo, "x", (unsigned int)&httpTransaction);
+ info, "x", (unsigned int)&httpTransaction);
return retVal;
}
AFTER_ORIGINAL_TIZEN_SOCK("HttpSession::CloseAllTransactions", VT_ULONG,
retVal, (unsigned int)this, (unsigned int)this,
- HTTP_API_TRANSACTION_CLOSE, "", 0, hostinfo, "s", "void");
+ HTTP_API_TRANSACTION_CLOSE, info, "s", "void");
return retVal;
}
AFTER_ORIGINAL_TIZEN_SOCK("HttpSession::SetAutoRedirectionEnabled",
VT_ULONG, retVal, (unsigned int)this, (unsigned int)this,
- HTTP_API_OTHER, "", 0, hostinfo, "d", enable);
+ HTTP_API_OTHER, info, "d", enable);
return retVal;
}
retVal = (this->*IsAutoRedirectionEnabledp)();
AFTER_ORIGINAL_TIZEN_SOCK("HttpSession::IsAutoRedirectionEnabled", VT_INT,
- retVal, (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, "",
- 0, hostinfo, "s", "void");
+ retVal, (unsigned int)this, (unsigned int)this,
+ HTTP_API_OTHER, info, "s", "void");
return retVal;
}
retVal = (this->*GetActiveTransactionCountp)();
AFTER_ORIGINAL_TIZEN_SOCK("HttpSession::GetActiveTransactionCount", VT_INT,
- retVal, (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, "",
- 0, hostinfo, "s", "void");
+ retVal, (unsigned int)this, (unsigned int)this,
+ HTTP_API_OTHER, info, "s", "void");
return retVal;
}
retVal = (this->*GetMaxTransactionCountp)();
AFTER_ORIGINAL_TIZEN_SOCK("HttpSession::GetMaxTransactionCount", VT_INT,
- retVal, (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, "",
- 0, hostinfo, "s", "void");
+ retVal, (unsigned int)this, (unsigned int)this,
+ HTTP_API_OTHER, info, "s", "void");
return retVal;
}
newerrno = 1;
AFTER_ORIGINAL_TIZEN_SOCK("HttpSession::GetCookieStorageManager", VT_PTR,
retVal, (unsigned int)this, (unsigned int)this, HTTP_API_ALLOCATION,
- "", 0, hostinfo, "s", "void");
+ info, "s", "void");
return retVal;
}
newerrno = 1;
AFTER_ORIGINAL_TIZEN_SOCK("HttpTransaction::OpenAuthenticationInfoN",
VT_PTR, retVal, (unsigned int)this, (unsigned int)this,
- HTTP_API_ALLOCATION, "", 0, hostinfo, "s", "void");
+ HTTP_API_ALLOCATION, info, "s", "void");
return retVal;
}
if (retVal == NULL)
newerrno = 1;
AFTER_ORIGINAL_TIZEN_SOCK("HttpTransaction::GetRequest", VT_PTR, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_ALLOCATION, "", 0,
- hostinfo, "s", "void");
+ (unsigned int)this, (unsigned int)this,
+ HTTP_API_ALLOCATION, info, "s", "void");
return retVal;
}
if (retVal == NULL)
newerrno = 1;
AFTER_ORIGINAL_TIZEN_SOCK("HttpTransaction::GetResponse", VT_PTR, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_ALLOCATION, "", 0,
- hostinfo, "s", "void");
+ (unsigned int)this, (unsigned int)this,
+ HTTP_API_ALLOCATION, info, "s", "void");
return retVal;
}
AFTER_ORIGINAL_TIZEN_SOCK("HttpTransaction::AddHttpTransactionListener",
VT_ULONG, retVal, (unsigned int)this, (unsigned int)this,
- HTTP_API_OTHER, "", 0, hostinfo, "x", (unsigned int)&listener);
+ HTTP_API_OTHER, info, "x", (unsigned int)&listener);
return retVal;
}
AFTER_ORIGINAL_TIZEN_SOCK("HttpTransaction::RemoveHttpTransactionListener",
VT_ULONG, retVal, (unsigned int)this, (unsigned int)this,
- HTTP_API_OTHER, "", 0, hostinfo, "x", (unsigned int)&listener);
+ HTTP_API_OTHER, info, "x", (unsigned int)&listener);
return retVal;
}
AFTER_ORIGINAL_TIZEN_SOCK("HttpTransaction::SetHttpProgressListener",
VT_ULONG, retVal, (unsigned int)this, (unsigned int)this,
- HTTP_API_OTHER, "", 0, hostinfo, "x", (unsigned int)&listener);
+ HTTP_API_OTHER, info, "x", (unsigned int)&listener);
return retVal;
}
retVal = (this->*SetUserObjectp)(pUserData);
AFTER_ORIGINAL_TIZEN_SOCK("HttpTransaction::SetUserObject", VT_ULONG,
- retVal, (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, "",
- 0, hostinfo, "x", (unsigned int)&pUserData);
+ retVal, (unsigned int)this, (unsigned int)this,
+ HTTP_API_OTHER, info, "x",
+ (unsigned int)&pUserData);
return retVal;
}
retVal = (this->*GetUserObjectp)();
AFTER_ORIGINAL_TIZEN_SOCK("HttpTransaction::GetUserObject", VT_PTR, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, info,
"s", "void");
return retVal;
}
retVal = (this->*EnableTransactionReadyToWritep)();
AFTER_ORIGINAL_TIZEN_SOCK("HttpTransaction::GetUserObject", VT_INT, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, info,
"s", "void");
return retVal;
}
retVal = (this->*Submitp)();
AFTER_ORIGINAL_TIZEN_SOCK("HttpTransaction::Submit", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_SUBMIT, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, HTTP_API_SUBMIT, info,
"s", "void");
return retVal;
}
retVal = (this->*Resumep)();
AFTER_ORIGINAL_TIZEN_SOCK("HttpTransaction::Resume", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, info,
"s", "void");
return retVal;
}
retVal = (this->*Pausep)();
AFTER_ORIGINAL_TIZEN_SOCK("HttpTransaction::Pause", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, info,
"s", "void");
return retVal;
}
retVal = (this->*SetClientCertificatep)(certificateId);
AFTER_ORIGINAL_TIZEN_SOCK("HttpTransaction::SetClientCertificate", VT_ULONG,
- retVal, (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, "",
- 0, hostinfo, "d", certificateId);
+ retVal, (unsigned int)this, (unsigned int)this,
+ HTTP_API_OTHER, info, "d", certificateId);
return retVal;
}
retVal = (this->*SetTimeoutp)(timeout);
AFTER_ORIGINAL_TIZEN_SOCK("HttpTransaction::SetTimeout", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, info,
"d", timeout);
return retVal;
}
retVal = (this->*SetServerCertificateVerificationp)(flag);
- AFTER_ORIGINAL_TIZEN_SOCK(
- "HttpTransaction::SetServerCertificateVerification", VT_ULONG,
- retVal, (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, "",
- 0, hostinfo, "d", flag);
+ AFTER_ORIGINAL_TIZEN_SOCK("HttpTransaction::SetServerCertificateVerification",
+ VT_ULONG, retVal, (unsigned int)this,
+ (unsigned int)this, HTTP_API_OTHER, info, "d",
+ flag);
return retVal;
}
retVal = (this->*SetMethodp)(method);
AFTER_ORIGINAL_TIZEN_SOCK("HttpRequest::SetMethod", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, info,
"d", method);
return retVal;
}
int nSize = method.GetLength();
char temp[nSize];
WcharToChar(temp, method.GetPointer());
-
- AFTER_ORIGINAL_TIZEN_SOCK("HttpRequest::SetCustomMethod", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_REQUEST, temp,
- nSize, hostinfo, "x", (unsigned int)&method);
+ info.msg_buf = temp;
+ info.msg_total_size = nSize;
+ info.msg_pack_size = nSize;
+
+ AFTER_ORIGINAL_TIZEN_SOCK("HttpRequest::SetCustomMethod", VT_ULONG,
+ retVal, (unsigned int)this, (unsigned int)this,
+ HTTP_API_REQUEST, info, "x",
+ (unsigned int)&method);
return retVal;
}
retVal = (this->*SetVersionp)(version);
AFTER_ORIGINAL_TIZEN_SOCK("HttpRequest::SetVersion", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, info,
"d", version);
return retVal;
}
WcharToChar(temp, uri.GetPointer());
AFTER_ORIGINAL_TIZEN_SOCK("HttpRequest::SetUri", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_REQUEST, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, HTTP_API_REQUEST, info,
"s", temp);
return retVal;
}
strData.SetCapacity(bufferSize);
strData.Append(pBuffer);
char* out = new char[bufferSize];
- int socketSendSize = SOCKET_SEND_SIZE;
- if (socketSendSize != 0 && socketSendSize < bufferSize) {
- out[socketSendSize + 1] = '.';
- out[socketSendSize + 2] = '.';
- out[socketSendSize + 3] = '.';
- out[socketSendSize + 4] = '\0';
- }
+ WcharToChar(out, strData.GetPointer());
+
+ info.msg_buf = out;
+ info.msg_pack_size = bufferSize > SOCKET_SEND_SIZE ? SOCKET_SEND_SIZE : bufferSize;
+ info.msg_total_size = bufferSize;
AFTER_ORIGINAL_TIZEN_SOCK("HttpRequest::WriteBody", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_REQUEST, out,
- body.GetLimit(), hostinfo, "x", (unsigned int)&body);
+ (unsigned int)this, (unsigned int)this,
+ HTTP_API_REQUEST, info, "x",
+ (unsigned int)&body);
delete [] out;
return retVal;
}
retVal = (this->*SetEntityp)(entity);
AFTER_ORIGINAL_TIZEN_SOCK("HttpRequest::SetEntity", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, info,
"x", (unsigned int)& entity);
return retVal;
}
if (retVal == NULL)
newerrno = 1;
AFTER_ORIGINAL_TIZEN_SOCK("HttpRequest::GetHeader", VT_PTR, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_ALLOCATION, "", 0,
- hostinfo, "s", "void");
+ (unsigned int)this, (unsigned int)this,
+ HTTP_API_ALLOCATION, info, "s", "void");
return retVal;
}
int nSize = cookieString.GetLength();
char temp[nSize];
WcharToChar(temp, cookieString.GetPointer());
+ info.msg_buf = temp;
+ info.msg_total_size = nSize;
+ info.msg_pack_size = nSize > SOCKET_SEND_SIZE ? SOCKET_SEND_SIZE : nSize;
AFTER_ORIGINAL_TIZEN_SOCK("HttpRequest::SetCookie", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_REQUEST, temp,
- nSize, hostinfo, "x", (unsigned int)&cookieString);
+ (unsigned int)this, (unsigned int)this,
+ HTTP_API_REQUEST, info, "x",
+ (unsigned int)&cookieString);
return retVal;
}
int nSize = retVal.GetLength();
char temp[nSize];
WcharToChar(temp, retVal.GetPointer());
+ info.msg_buf = temp;
+ info.msg_total_size = nSize;
+ info.msg_pack_size = nSize > SOCKET_SEND_SIZE ? SOCKET_SEND_SIZE : nSize;
AFTER_ORIGINAL_TIZEN_SOCK("HttpRequest::GetCookie", VT_PTR,
- (unsigned int)&retVal, (unsigned int)this, (unsigned int)this,
- HTTP_API_OTHER, temp, nSize, hostinfo, "s", "void");
+ (unsigned int)&retVal,
+ (unsigned int)this, (unsigned int)this,
+ HTTP_API_OTHER, info, "s", "void");
return retVal;
}
int nSize = encoding.GetLength();
char temp[nSize];
WcharToChar(temp, encoding.GetPointer());
+ info.msg_buf = temp;
+ info.msg_total_size = nSize;
+ info.msg_pack_size = nSize > SOCKET_SEND_SIZE ? SOCKET_SEND_SIZE : nSize;
AFTER_ORIGINAL_TIZEN_SOCK("HttpRequest::SetAcceptEncoding", VT_ULONG,
- retVal, (unsigned int)this, (unsigned int)this, HTTP_API_REQUEST,
- temp, nSize, hostinfo, "s", temp);
+ retVal, (unsigned int)this, (unsigned int)this,
+ HTTP_API_REQUEST, info, "s", temp);
return retVal;
}
copybuffer.Construct(bufferSize + 4);
copybuffer.CopyFrom(*retVal);
- char* out = (char*) (copybuffer.GetPointer());
- int socketSendSize = SOCKET_SEND_SIZE;
- if (socketSendSize != 0 && socketSendSize < bufferSize) {
- out[socketSendSize + 1] = '.';
- out[socketSendSize + 2] = '.';
- out[socketSendSize + 3] = '.';
- out[socketSendSize + 4] = '\0';
- }
+ info.msg_buf = (char *)(copybuffer.GetPointer());
+ info.msg_total_size = bufferSize;
+ info.msg_pack_size = bufferSize > SOCKET_SEND_SIZE ? SOCKET_SEND_SIZE : bufferSize;
AFTER_ORIGINAL_TIZEN_SOCK("HttpRequest::ReadBodyN", VT_PTR,
- (unsigned int)&retVal, (unsigned int)this, (unsigned int)this,
- HTTP_API_OTHER, out, retVal->GetLimit(), hostinfo, "s", "void");
+ (unsigned int)&retVal,
+ (unsigned int)this, (unsigned int)this,
+ HTTP_API_OTHER, info, "s", "void");
return retVal;
}
int nSize = retVal.GetLength();
char temp[nSize];
WcharToChar(temp, retVal.GetPointer());
+ info.msg_buf = temp;
+ info.msg_total_size = nSize;
+ info.msg_pack_size = nSize > SOCKET_SEND_SIZE ? SOCKET_SEND_SIZE : nSize;
AFTER_ORIGINAL_TIZEN_SOCK("HttpRequest::GetAcceptEncoding", VT_PTR,
- (unsigned int)&retVal, (unsigned int)this, (unsigned int)this,
- HTTP_API_OTHER, temp, nSize, hostinfo, "s", "void");
+ (unsigned int)&retVal,
+ (unsigned int)this, (unsigned int)this,
+ HTTP_API_OTHER, info, "s", "void");
return retVal;
}
retVal = (this->*GetHttpStatusCodep)();
AFTER_ORIGINAL_TIZEN_SOCK("HttpResponse::GetStatusCode", VT_INT, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, info,
"s", "void");
return retVal;
retVal = (this->*GetHttpStatusCodep)();
AFTER_ORIGINAL_TIZEN_SOCK("HttpResponse::GetHttpStatusCode", VT_INT, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, info,
"s", "void");
return retVal;
}
char temp[nSize];
WcharToChar(temp, retVal.GetPointer());
+ info.msg_buf = temp;
+ info.msg_total_size = nSize;
+ info.msg_pack_size = nSize > SOCKET_SEND_SIZE ? SOCKET_SEND_SIZE : nSize;
+
AFTER_ORIGINAL_TIZEN_SOCK("HttpResponse::GetStatusText", VT_PTR,
(unsigned int)&retVal, (unsigned int)this, (unsigned int)this,
- HTTP_API_RESPONSE, temp, nSize, hostinfo, "s", "void");
+ HTTP_API_RESPONSE, info, "s", "void");
return retVal;
}
char temp[nSize];
WcharToChar(temp, retVal.GetPointer());
+ info.msg_buf = temp;
+ info.msg_total_size = nSize;
+ info.msg_pack_size = nSize > SOCKET_SEND_SIZE ? SOCKET_SEND_SIZE : nSize;
+
AFTER_ORIGINAL_TIZEN_SOCK("HttpResponse::GetVersion", VT_PTR,
(unsigned int)&retVal, (unsigned int)this, (unsigned int)this,
- HTTP_API_RESPONSE, temp, nSize, hostinfo, "s", "void");
+ HTTP_API_RESPONSE, info, "s", "void");
return retVal;
}
if (retVal == NULL)
newerrno = 1;
AFTER_ORIGINAL_TIZEN_SOCK("HttpResponse::GetHeader", VT_PTR, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_ALLOCATION, "", 0,
- hostinfo, "s", "void");
+ (unsigned int)this, (unsigned int)this, HTTP_API_ALLOCATION,
+ info, "s", "void");
return retVal;
}
copybuffer.CopyFrom(*retVal);
char* out = (char*) (copybuffer.GetPointer());
- int socketSendSize = SOCKET_SEND_SIZE;
- if (socketSendSize != 0 && socketSendSize < bufferSize) {
- out[socketSendSize + 1] = '.';
- out[socketSendSize + 2] = '.';
- out[socketSendSize + 3] = '.';
- out[socketSendSize + 4] = '\0';
- }
+
+ info.msg_buf = out;
+ info.msg_pack_size = bufferSize > SOCKET_SEND_SIZE ? SOCKET_SEND_SIZE : bufferSize;
+ info.msg_total_size = bufferSize;
AFTER_ORIGINAL_TIZEN_SOCK("HttpResponse::ReadBodyN", VT_PTR,
(unsigned int)&retVal, (unsigned int)this, (unsigned int)this,
- HTTP_API_RESPONSE, out, retVal->GetLimit(), hostinfo, "s", "void");
+ HTTP_API_RESPONSE, info, "s", "void");
return retVal;
}
newerrno = 1;
AFTER_ORIGINAL_TIZEN_SOCK("HttpResponse::GetCookies", VT_PTR,
(unsigned int)&retVal, (unsigned int)this, (unsigned int)this,
- HTTP_API_OTHER, "", 0, hostinfo, "s", "void");
+ HTTP_API_OTHER, info, "s", "void");
return retVal;
}
retVal = (this->*SetStatusCodep)(statusCode);
AFTER_ORIGINAL_TIZEN_SOCK("HttpResponse::SetStatusCode", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, info,
"d", statusCode);
return retVal;
}
retVal = (this->*SetHttpStatusCodep)(statusCode);
AFTER_ORIGINAL_TIZEN_SOCK("HttpResponse::SetHttpStatusCode", VT_ULONG,
- retVal, (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, "",
- 0, hostinfo, "d", statusCode);
+ retVal, (unsigned int)this, (unsigned int)this,
+ HTTP_API_OTHER, info, "d", statusCode);
return retVal;
}
WcharToChar(temp, statusText.GetPointer());
AFTER_ORIGINAL_TIZEN_SOCK("HttpResponse::SetStatusText", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, info,
"s", temp);
return retVal;
}
WcharToChar(temp, httpVersion.GetPointer());
AFTER_ORIGINAL_TIZEN_SOCK("HttpResponse::SetVersion", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, info,
"s", temp);
return retVal;
}
strData.SetCapacity(bufferSize);
strData.Append(pBuffer);
char* out = new char[bufferSize];
- int socketSendSize = SOCKET_SEND_SIZE;
- if (socketSendSize != 0 && socketSendSize < bufferSize) {
- out[socketSendSize + 1] = '.';
- out[socketSendSize + 2] = '.';
- out[socketSendSize + 3] = '.';
- out[socketSendSize + 4] = '\0';
- }
+ WcharToChar(out, strData.GetPointer());
+
+ info.msg_buf = out;
+ info.msg_pack_size = bufferSize > SOCKET_SEND_SIZE ? SOCKET_SEND_SIZE : bufferSize;
+ info.msg_total_size = bufferSize;
AFTER_ORIGINAL_TIZEN_SOCK("HttpResponse::WriteBody", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_RESPONSE, out,
- body.GetLimit(), hostinfo, "x", (unsigned int)&body);
+ (unsigned int)this, (unsigned int)this, HTTP_API_RESPONSE,
+ info, "x", (unsigned int)&body);
delete out;
return retVal;
}
retVal = (this->*Readp)(headerLen, bodyLen, rcvHeaderLen, rcvBodyLen);
AFTER_ORIGINAL_TIZEN_SOCK("HttpResponse::Read", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, info,
"ddxx",
headerLen, bodyLen, (unsigned int)&rcvHeaderLen, (unsigned int)&rcvBodyLen);
return retVal;
retVal = (this->*SetCookiep)(pHeader);
AFTER_ORIGINAL_TIZEN_SOCK("HttpResponse::SetCookie", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, info,
"x", (unsigned int)&pHeader);
return retVal;
}
retVal = (this->*Constructp)(addressFamily, socketType, protocol);
AFTER_ORIGINAL_TIZEN_SOCK("Socket::Construct", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, SOCKET_API_FD_OPEN, "", 0,
- hostinfo, "ddd", addressFamily, socketType, protocol);
+ (unsigned int)this, (unsigned int)this, SOCKET_API_FD_OPEN,
+ info, "ddd", addressFamily, socketType, protocol);
return retVal;
}
protocol);
AFTER_ORIGINAL_TIZEN_SOCK("Socket::Construct", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, SOCKET_API_FD_OPEN, "", 0,
- hostinfo, "xddd",
+ (unsigned int)this, (unsigned int)this, SOCKET_API_FD_OPEN,
+ info, "xddd",
(unsigned int)&netConnection, addressFamily, socketType, protocol);
return retVal;
AcceptNp);
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_START("Socket::AcceptN", VT_NULL, NULL,
- (unsigned int)this, (unsigned int)this, SOCKET_API_ACCEPT_START, "",
- 0, hostinfo, "s", "void");
+ (unsigned int)this, (unsigned int)this, SOCKET_API_ACCEPT_START,
+ info, "s", "void");
pret = (this->*AcceptNp)();
if (pret == NULL)
newerrno = 1;
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_END("Socket::AcceptN", VT_PTR, pret,
- (unsigned int)this, (unsigned int)this, SOCKET_API_ACCEPT_END, "",
- 0, hostinfo, "s", "void");
+ (unsigned int)this, (unsigned int)this, SOCKET_API_ACCEPT_END,
+ info, "s", "void");
return pret;
}
WcharToChar(temp, iv4PeerAddr->ToString().GetPointer());
char addressInfo[64];
sprintf(addressInfo, "%s:%d", temp, remoteEndPoint.GetPort());
- hostinfo.port = remoteEndPoint.GetPort();
- iv4PeerAddr->GetAddress(&hostinfo.ip);
+ info.host_port = remoteEndPoint.GetPort();
+ iv4PeerAddr->GetAddress(&info.host_ip);
retVal = (this->*Connectp)(remoteEndPoint);
AFTER_ORIGINAL_TIZEN_SOCK("Socket::Connect", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, SOCKET_API_CONNECT, "", 0,
- hostinfo, "s", addressInfo);
+ (unsigned int)this, (unsigned int)this, SOCKET_API_CONNECT,
+ info, "s", addressInfo);
return retVal;
}
retVal = (this->*Closep)();
AFTER_ORIGINAL_TIZEN_SOCK("Socket::Close", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, SOCKET_API_FD_CLOSE, "", 0,
- hostinfo, "s", "void");
+ (unsigned int)this, (unsigned int)this, SOCKET_API_FD_CLOSE,
+ info, "s", "void");
return retVal;
}
WcharToChar(temp, iv4PeerAddr->ToString().GetPointer());
char addressInfo[64];
sprintf(addressInfo, "%s:%d", temp, localEndPoint.GetPort());
- hostinfo.port = localEndPoint.GetPort();
- iv4PeerAddr->GetAddress(&hostinfo.ip);
+ info.host_port = localEndPoint.GetPort();
+ iv4PeerAddr->GetAddress(&info.host_ip);
AFTER_ORIGINAL_TIZEN_SOCK("Socket::Bind", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, SOCKET_API_BIND, "", 0,
- hostinfo, "s", addressInfo);
+ (unsigned int)this, (unsigned int)this, SOCKET_API_BIND,
+ info, "s", addressInfo);
return retVal;
}
retVal = (this->*Listenp)(backLog);
AFTER_ORIGINAL_TIZEN_SOCK("Socket::Listen", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, SOCKET_API_LISTEN, "", 0,
- hostinfo, "d", backLog);
+ (unsigned int)this, (unsigned int)this, SOCKET_API_LISTEN,
+ info, "d", backLog);
return retVal;
}
Receivep);
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_START("Socket::Receive", VT_NULL, NULL,
- (unsigned int)this, (unsigned int)this, SOCKET_API_RECV_START, "",
- 0, hostinfo, "x", (unsigned int)&buffer);
+ (unsigned int)this, (unsigned int)this, SOCKET_API_RECV_START,
+ info, "x", (unsigned int)&buffer);
pret = (this->*Receivep)(buffer);
- int bufferSize = buffer.GetLimit();
- char* pBuffer = (char*) (buffer.GetPointer());
- Tizen::Base::String strData;
- strData.SetCapacity(bufferSize);
- strData.Append(pBuffer);
- char* out = new char[bufferSize];
- WcharToChar(out, strData.GetPointer());
- int socketSendSize = SOCKET_SEND_SIZE;
- if (socketSendSize != 0 && socketSendSize < bufferSize) {
- out[socketSendSize + 1] = '.';
- out[socketSendSize + 2] = '.';
- out[socketSendSize + 3] = '.';
- out[socketSendSize + 4] = '\0';
- }
+ info.msg_total_size = buffer.GetLimit();
+ info.msg_pack_size = info.msg_total_size;
+ info.msg_buf = (char*)(buffer.GetPointer());
+
+ if (info.msg_pack_size > SOCKET_SEND_SIZE)
+ info.msg_pack_size = SOCKET_SEND_SIZE;
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_END("Socket::Receive", VT_ULONG, pret,
- (unsigned int)this, (unsigned int)this, SOCKET_API_RECV_END, out,
- buffer.GetLimit(), hostinfo, "x", (unsigned int)&buffer);
- delete [] out;
+ (unsigned int)this, (unsigned int)this, SOCKET_API_RECV_END,
+ info, "x", (unsigned int)&buffer);
return pret;
}
Receivep);
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_START("Socket::Receive", VT_NULL, NULL,
- (unsigned int)this, (unsigned int)this, SOCKET_API_RECV_START, "",
- 0, hostinfo, "xdx",
+ (unsigned int)this, (unsigned int)this, SOCKET_API_RECV_START,
+ info, "xdx",
(unsigned int)&pBuffer, length, rcvdLength);
pret = (this->*Receivep)(pBuffer, length, rcvdLength);
+ info.msg_buf = (char *)pBuffer;
+ info.msg_total_size = rcvdLength;
+ info.msg_pack_size = rcvdLength > SOCKET_SEND_SIZE ? SOCKET_SEND_SIZE : rcvdLength;
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_END("Socket::Receive", VT_ULONG, pret,
(unsigned int)this, (unsigned int)this, SOCKET_API_RECV_END,
- (char*)pBuffer, length, hostinfo, "xdx",
- (unsigned int)&pBuffer, length, rcvdLength);
+ info, "xdx", (unsigned int)&pBuffer, length, rcvdLength);
return pret;
}
WcharToChar(temp, iv4PeerAddr->ToString().GetPointer());
char addressInfo[64];
sprintf(addressInfo, "%s:%d", temp, remoteEndPoint.GetPort());
- hostinfo.port = remoteEndPoint.GetPort();
- iv4PeerAddr->GetAddress(&hostinfo.ip);
+ info.host_port = remoteEndPoint.GetPort();
+ iv4PeerAddr->GetAddress(&info.host_ip);
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_START("Socket::ReceiveFrom", VT_NULL,
NULL, (unsigned int)this, (unsigned int)this, SOCKET_API_RECV_START,
- "", 0,
- hostinfo, "xs", (unsigned int)&buffer, temp);
+
+ info, "xs", (unsigned int)&buffer, temp);
pret = (this->*ReceiveFromp)(buffer, remoteEndPoint);
strData.Append(pBuffer);
char* out = new char[bufferSize];
WcharToChar(out, strData.GetPointer());
- int socketSendSize = SOCKET_SEND_SIZE;
- if (socketSendSize != 0 && socketSendSize < bufferSize) {
- out[socketSendSize + 1] = '.';
- out[socketSendSize + 2] = '.';
- out[socketSendSize + 3] = '.';
- out[socketSendSize + 4] = '\0';
- }
+
+ info.msg_buf = out;
+ info.msg_total_size = bufferSize;
+ info.msg_pack_size = bufferSize > SOCKET_SEND_SIZE ? SOCKET_SEND_SIZE : bufferSize;
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_END("Socket::ReceiveFrom", VT_ULONG,
pret, (unsigned int)this, (unsigned int)this, SOCKET_API_RECV_END,
- out, buffer.GetLimit(), hostinfo, "xs",
- (unsigned int)&buffer, temp);
+ info, "xs", (unsigned int)&buffer, temp);
delete [] out;
return pret;
}
WcharToChar(temp, iv4PeerAddr->ToString().GetPointer());
char addressInfo[64];
sprintf(addressInfo, "%s:%d", temp, remoteEndPoint.GetPort());
- hostinfo.port = remoteEndPoint.GetPort();
- iv4PeerAddr->GetAddress(&hostinfo.ip);
+ info.host_port = remoteEndPoint.GetPort();
+ iv4PeerAddr->GetAddress(&info.host_ip);
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_START("Socket::ReceiveFrom", VT_NULL,
NULL, (unsigned int)this, (unsigned int)this, SOCKET_API_RECV_START,
- "", 0, hostinfo, "xdsx",
+ info, "xdsx",
(unsigned int)&pBuffer, length, temp, rcvdLength);
pret = (this->*ReceiveFromp)(pBuffer, length, remoteEndPoint, rcvdLength);
+ info.msg_buf = (char *)pBuffer;
+ info.msg_total_size = length;
+ info.msg_pack_size = length > SOCKET_SEND_SIZE ? SOCKET_SEND_SIZE : length;
+
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_END("Socket::ReceiveFrom", VT_ULONG,
pret, (unsigned int)this, (unsigned int)this, SOCKET_API_RECV_END,
- (char*)pBuffer, length, hostinfo, "xdsx",
- (unsigned int)&pBuffer, length, temp, rcvdLength);
+ info, "xdsx", (unsigned int)&pBuffer, length, temp, rcvdLength);
return pret;
}
_ZN5Tizen3Net7Sockets6Socket4SendERNS_4Base10ByteBufferE, Sendp);
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_START("Socket::Send", VT_NULL, NULL,
- (unsigned int)this, (unsigned int)this, SOCKET_API_SEND_START, "",
- 0, hostinfo, "x", (unsigned int)&buffer);
+ (unsigned int)this, (unsigned int)this, SOCKET_API_SEND_START,
+ info, "x", (unsigned int)&buffer);
pret = (this->*Sendp)(buffer);
int bufferSize = buffer.GetLimit();
strData.Append(pBuffer);
char* out = new char[bufferSize];
WcharToChar(out, strData.GetPointer());
- int socketSendSize = SOCKET_SEND_SIZE;
- if (socketSendSize != 0 && socketSendSize < bufferSize) {
- out[socketSendSize + 1] = '.';
- out[socketSendSize + 2] = '.';
- out[socketSendSize + 3] = '.';
- out[socketSendSize + 4] = '\0';
- }
+
+ info.msg_buf = out;
+ info.msg_total_size = bufferSize;
+ info.msg_pack_size = bufferSize > SOCKET_SEND_SIZE ? SOCKET_SEND_SIZE : bufferSize;
+
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_END("Socket::Send", VT_ULONG, pret,
- (unsigned int)this, (unsigned int)this, SOCKET_API_SEND_END, out,
- buffer.GetLimit(), hostinfo, "x", (unsigned int)&buffer);
+ (unsigned int)this, (unsigned int)this, SOCKET_API_SEND_END,
+ info, "x", (unsigned int)&buffer);
delete [] out;
return pret;
}
Sendp);
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_START("Socket::Send", VT_NULL, NULL,
- (unsigned int)this, (unsigned int)this, SOCKET_API_SEND_START, "",
- 0, hostinfo, "xdx",
+ (unsigned int)this, (unsigned int)this, SOCKET_API_SEND_START,
+ info, "xdx",
(unsigned int)&pBuffer, length, (unsigned int)&sentLength);
pret = (this->*Sendp)(pBuffer, length, sentLength);
+ info.msg_buf = (char *)pBuffer;
+ info.msg_total_size = length;
+ info.msg_pack_size = length > SOCKET_SEND_SIZE ? SOCKET_SEND_SIZE : length;
+
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_END("Socket::Send", VT_ULONG, pret,
(unsigned int)this, (unsigned int)this, SOCKET_API_SEND_END,
- (char*)pBuffer, length, hostinfo, "xdx",
- (unsigned int)&pBuffer, length, (unsigned int)&sentLength);
+ info, "xdx", (unsigned int)&pBuffer, length, (unsigned int)&sentLength);
return pret;
WcharToChar(temp, iv4PeerAddr->ToString().GetPointer());
char addressInfo[64];
sprintf(addressInfo, "%s:%d", temp, remoteEndPoint.GetPort());
- hostinfo.port = remoteEndPoint.GetPort();
- iv4PeerAddr->GetAddress(&hostinfo.ip);
+ info.host_port = remoteEndPoint.GetPort();
+ iv4PeerAddr->GetAddress(&info.host_ip);
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_START("Socket::SendTo", VT_NULL, NULL,
- (unsigned int)this, (unsigned int)this, SOCKET_API_SEND_START, "",
- 0, hostinfo, "xs", (unsigned int)&buffer, temp);
+ (unsigned int)this, (unsigned int)this, SOCKET_API_SEND_START,
+ info, "xs", (unsigned int)&buffer, temp);
pret = (this->*SendTop)(buffer, remoteEndPoint);
strData.Append(pBuffer);
char* out = new char[bufferSize];
WcharToChar(out, strData.GetPointer());
- int socketSendSize = SOCKET_SEND_SIZE;
- if (socketSendSize != 0 && socketSendSize < bufferSize) {
- out[socketSendSize + 1] = '.';
- out[socketSendSize + 2] = '.';
- out[socketSendSize + 3] = '.';
- out[socketSendSize + 4] = '\0';
- }
+
+ info.msg_buf = out;
+ info.msg_total_size = bufferSize;
+ info.msg_pack_size = bufferSize > SOCKET_SEND_SIZE ? SOCKET_SEND_SIZE : bufferSize;
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_END("Socket::SendTo", VT_ULONG, pret,
- (unsigned int)this, (unsigned int)this, SOCKET_API_SEND_END, out,
- buffer.GetLimit(), hostinfo, "xs", (unsigned int)&buffer, temp);
+ (unsigned int)this, (unsigned int)this, SOCKET_API_SEND_END,
+ info, "xs", (unsigned int)&buffer, temp);
delete [] out;
return pret;
}
WcharToChar(temp, iv4PeerAddr->ToString().GetPointer());
char addressInfo[64];
sprintf(addressInfo, "%s:%d", temp, remoteEndPoint.GetPort());
- hostinfo.port = remoteEndPoint.GetPort();
- iv4PeerAddr->GetAddress(&hostinfo.ip);
+ info.host_port = remoteEndPoint.GetPort();
+ iv4PeerAddr->GetAddress(&info.host_ip);
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_START("Socket::SendTo", VT_NULL, NULL,
- (unsigned int)this, (unsigned int)this, SOCKET_API_SEND_START, "",
- 0, hostinfo, "xdsx,",
+ (unsigned int)this, (unsigned int)this, SOCKET_API_SEND_START,
+ info, "xdsx,",
(unsigned int)&pBuffer, length, temp, (unsigned int)&sentLength);
pret = (this->*SendTop)(pBuffer, length, remoteEndPoint, sentLength);
+ info.msg_buf = (char *)pBuffer;
+ info.msg_total_size = length;
+ info.msg_pack_size = length > SOCKET_SEND_SIZE ? SOCKET_SEND_SIZE : length;
+
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_END("Socket::SendTo", VT_ULONG, pret,
(unsigned int)this, (unsigned int)this, SOCKET_API_SEND_END,
- (char*)pBuffer, length, hostinfo, "xdsx,",
- (unsigned int)&pBuffer, length, temp, (unsigned int)&sentLength);
+ info, "xdsx,", (unsigned int)&pBuffer, length, temp,
+ (unsigned int)&sentLength);
return pret;
retVal = (this->*AddSocketListenerp)(listener);
AFTER_ORIGINAL_TIZEN_SOCK("Socket::AddSocketListener", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, SOCKET_API_OTHER, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, SOCKET_API_OTHER, info,
"x", (unsigned int) &listener);
return retVal;
retVal = (this->*AsyncSelectByListenerp)(socketEventType);
AFTER_ORIGINAL_TIZEN_SOCK("Socket::AsyncSelectByListener", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, SOCKET_API_OTHER, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, SOCKET_API_OTHER, info,
"x", socketEventType);
return retVal;
retVal = (this->*Ioctlp)(cmd, value);
AFTER_ORIGINAL_TIZEN_SOCK("Socket::Ioctl", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, SOCKET_API_OTHER, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, SOCKET_API_OTHER, info,
"dx", cmd, (unsigned int) &value);
return retVal;
retVal = (this->*SetSockOptp)(optionLevel, optionName, optionValue);
AFTER_ORIGINAL_TIZEN_SOCK("Socket::SetSockOpt", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, SOCKET_API_OTHER, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, SOCKET_API_OTHER, info,
"ddd", optionLevel, optionName, optionValue);
return retVal;
retVal = (this->*SetSockOptp)(optionLevel, optionName, optionValue);
AFTER_ORIGINAL_TIZEN_SOCK("Socket::SetSockOpt", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, SOCKET_API_OTHER, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, SOCKET_API_OTHER, info,
"ddx",
optionLevel, optionName, (unsigned int) &optionValue);
retVal = (this->*SetSockOptp)(optionLevel, optionName, optionValue);
AFTER_ORIGINAL_TIZEN_SOCK("Socket::SetSockOpt", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, SOCKET_API_OTHER, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, SOCKET_API_OTHER, info,
"ddx",
optionLevel, optionName, (unsigned int) &optionValue);
retVal = (this->*GetSockOptp)(optionLevel, optionName, optionValue);
AFTER_ORIGINAL_TIZEN_SOCK("Socket::GetSockOpt", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, SOCKET_API_OTHER, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, SOCKET_API_OTHER, info,
"ddx",
optionLevel, optionName, (unsigned int) &optionValue);
retVal = (this->*GetSockOptp)(optionLevel, optionName, optionValue);
AFTER_ORIGINAL_TIZEN_SOCK("Socket::GetSockOpt", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, SOCKET_API_OTHER, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, SOCKET_API_OTHER, info,
"ddx",
optionLevel, optionName, (unsigned int) &optionValue);
retVal = (this->*RemoveSocketListenerp)(listener);
AFTER_ORIGINAL_TIZEN_SOCK("Socket::RemoveSocketListener", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, SOCKET_API_OTHER, "", 0, hostinfo,
+ (unsigned int)this, (unsigned int)this, SOCKET_API_OTHER, info,
"x", (unsigned int) &listener);
return retVal;
projects / platform / core / system / swap-probe.git / commitdiff