version 1.16.8.3, 2013/08/22 11:52:20
|
version 1.18.2.1, 2013/09/05 00:27:10
|
Line 265 rpc_cli_closeClient(rpc_cli_t ** __restrict cli)
|
Line 265 rpc_cli_closeClient(rpc_cli_t ** __restrict cli)
|
int |
int |
rpc_pkt_Send(int sock, int type, sockaddr_t * __restrict sa, ait_val_t * __restrict pkt, int len) |
rpc_pkt_Send(int sock, int type, sockaddr_t * __restrict sa, ait_val_t * __restrict pkt, int len) |
{ |
{ |
struct pollfd pfd; |
|
int ret; |
|
u_char *buf; |
u_char *buf; |
|
|
if (!pkt) { |
if (!pkt) { |
Line 275 rpc_pkt_Send(int sock, int type, sockaddr_t * __restri
|
Line 273 rpc_pkt_Send(int sock, int type, sockaddr_t * __restri
|
} else |
} else |
buf = AIT_GET_BUF(pkt); |
buf = AIT_GET_BUF(pkt); |
|
|
pfd.fd = sock; | return rpc_Write(sock, type, MSG_NOSIGNAL, sa, buf, len); |
pfd.events = POLLOUT; | |
if ((ret = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 || | |
pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) { | |
if (ret) | |
LOGERR; | |
else | |
rpc_SetErr(ETIMEDOUT, "Timeout, can't send to RPC server"); | |
return -1; | |
} | |
do { | |
if (type == SOCK_STREAM) | |
ret = send(sock, buf, len, MSG_NOSIGNAL); | |
else if (sa) | |
ret = sendto(sock, buf, len, MSG_NOSIGNAL, &sa->sa, sa->sa.sa_len); | |
else { | |
rpc_SetErr(EINVAL, "Invalid argument(s)!"); | |
return -1; | |
} | |
if (ret == -1) { | |
if (errno == EAGAIN) | |
continue; | |
LOGERR; | |
return -1; | |
} else if (ret != len) { | |
rpc_SetErr(EPROCUNAVAIL, "RPC request, should be send %d bytes, " | |
"really sended %d bytes", len, ret); | |
return -1; | |
} | |
} while (0); | |
| |
return ret; | |
} |
} |
|
|
/* |
/* |
Line 321 rpc_pkt_Send(int sock, int type, sockaddr_t * __restri
|
Line 288 rpc_pkt_Send(int sock, int type, sockaddr_t * __restri
|
int |
int |
rpc_pkt_Receive(int sock, int type, sockaddr_t * __restrict sa, ait_val_t * __restrict pkt) |
rpc_pkt_Receive(int sock, int type, sockaddr_t * __restrict sa, ait_val_t * __restrict pkt) |
{ |
{ |
struct pollfd pfd; | int ret, estlen = 0, blen = sizeof(struct tagRPCCall); |
int ret, estlen, blen = sizeof(struct tagRPCCall), len = 0; | |
u_char *buf; |
u_char *buf; |
sockaddr_t sa2; |
|
socklen_t salen; |
|
struct tagRPCCall *rpc; |
struct tagRPCCall *rpc; |
|
|
if (!pkt) { |
if (!pkt) { |
Line 335 rpc_pkt_Receive(int sock, int type, sockaddr_t * __res
|
Line 299 rpc_pkt_Receive(int sock, int type, sockaddr_t * __res
|
buf = AIT_GET_BUF(pkt); |
buf = AIT_GET_BUF(pkt); |
|
|
/* reply from RPC server */ |
/* reply from RPC server */ |
pfd.fd = sock; |
|
pfd.events = POLLIN | POLLPRI; |
|
do { |
do { |
if ((ret = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 || | if (type == SOCK_STREAM) |
pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) { | ret = rpc_Read(sock, type, !estlen ? MSG_PEEK : 0, NULL, buf, blen); |
if (ret) { | else |
LOGERR; | ret = rpc_Read(sock, type, 0, sa, buf, AIT_LEN(pkt)); |
} else { | |
if (len++ < 7) | |
continue; | |
else | |
rpc_SetErr(ETIMEDOUT, | |
"Timeout, no answer from RPC server"); | |
} | |
| |
return -1; | |
} | |
| |
if (type == SOCK_STREAM) { | |
memset(buf, 0, blen); | |
ret = recv(sock, buf, blen, 0); | |
} else { | |
blen = AIT_LEN(pkt); | |
memset(buf, 0, blen); | |
memset(&sa2, 0, sizeof sa2); | |
salen = sa2.ss.ss_len = sizeof(sockaddr_t); | |
ret = recvfrom(sock, buf, blen, 0, &sa2.sa, &salen); | |
} | |
if (ret < 1) { |
if (ret < 1) { |
if (ret) { | LOGERR; |
if (errno == EAGAIN) | |
continue; | |
else | |
LOGERR; | |
} | |
return -1; |
return -1; |
} |
} |
|
|
/* check for response from known address */ |
/* check for response from known address */ |
if (type == SOCK_DGRAM) { | if (type == SOCK_STREAM && !estlen) { |
if (e_addrcmp(sa, &sa2, 42)) { | |
rpc_SetErr(ERPCMISMATCH, | |
"Received RPC response from unknown address"); | |
continue; | |
} | |
} else { | |
/* 1st read for RPC header */ |
/* 1st read for RPC header */ |
if (buf == AIT_GET_BUF(pkt)) { | if (ret < sizeof(struct tagRPCCall)) { |
if (ret < sizeof(struct tagRPCCall)) { | rpc_SetErr(ERPCMISMATCH, "Short RPC packet %d bytes", ret); |
rpc_SetErr(ERPCMISMATCH, "Short RPC packet %d bytes", ret); | return -1; |
return -1; | } |
} | |
|
|
/* calc estimated length */ | /* calc estimated length */ |
rpc = (struct tagRPCCall*) buf; | rpc = (struct tagRPCCall*) buf; |
estlen = ntohs(rpc->call_len) + blen; | estlen = ntohl(rpc->call_len); |
printf("ret = %d len=%d\n", ret, estlen); | if (estlen > AIT_LEN(pkt)) |
if (estlen > AIT_LEN(pkt)) | AIT_RE_BUF(pkt, estlen); |
AIT_RE_BUF(pkt, estlen); | buf = AIT_GET_BUF(pkt); |
buf = AIT_GET_BUF(pkt) + blen; | blen = estlen; |
blen = AIT_LEN(pkt) - blen; | rpc = (struct tagRPCCall*) buf; |
} else | continue; |
ret += sizeof(struct tagRPCCall); | |
} |
} |
} while (0); |
|
|
|
|
/* compiler optimize loop if while(0) and stop working 'continue' on some platforms */ |
|
break; |
|
} while (42); |
|
|
if (ret < sizeof(struct tagRPCCall)) { |
if (ret < sizeof(struct tagRPCCall)) { |
rpc_SetErr(ERPCMISMATCH, "Short RPC packet %d bytes", ret); |
rpc_SetErr(ERPCMISMATCH, "Short RPC packet %d bytes", ret); |
return -1; |
return -1; |
Line 449 rpc_pkt_Request(ait_val_t * __restrict pkt, rpc_sess_t
|
Line 380 rpc_pkt_Request(ait_val_t * __restrict pkt, rpc_sess_t
|
rpc->call_argc = htons(array_Size(vars)); |
rpc->call_argc = htons(array_Size(vars)); |
|
|
/* set reply */ |
/* set reply */ |
rpc->call_req.flags = noreply ? RPC_NOREPLY : RPC_REPLY; | rpc->call_req.flags = (uint64_t) htonl(noreply ? RPC_NOREPLY : RPC_REPLY); |
|
|
if (array_Size(vars)) { |
if (array_Size(vars)) { |
/* marshaling variables */ |
/* marshaling variables */ |
Line 462 rpc_pkt_Request(ait_val_t * __restrict pkt, rpc_sess_t
|
Line 393 rpc_pkt_Request(ait_val_t * __restrict pkt, rpc_sess_t
|
} |
} |
|
|
/* total packet length */ |
/* total packet length */ |
rpc->call_len = htons(len); | rpc->call_len = htonl(len); |
|
|
if (!nocrc) { |
if (!nocrc) { |
/* calculate CRC */ |
/* calculate CRC */ |
Line 503 rpc_pkt_Replay(ait_val_t * __restrict pkt, rpc_sess_t
|
Line 434 rpc_pkt_Replay(ait_val_t * __restrict pkt, rpc_sess_t
|
/* calculate CRC */ |
/* calculate CRC */ |
crc = ntohs(rpc->call_crc); |
crc = ntohs(rpc->call_crc); |
rpc->call_crc ^= rpc->call_crc; |
rpc->call_crc ^= rpc->call_crc; |
if (crc != crcFletcher16((u_short*) buf, ntohs(rpc->call_len) / 2)) { | if (crc != crcFletcher16((u_short*) buf, ntohl(rpc->call_len) / 2)) { |
rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet"); |
rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet"); |
return -1; |
return -1; |
} |
} |
Line 529 rpc_pkt_Replay(ait_val_t * __restrict pkt, rpc_sess_t
|
Line 460 rpc_pkt_Replay(ait_val_t * __restrict pkt, rpc_sess_t
|
rpc_SetErr(EMSGSIZE, "Reply RPC packet not enough buffer space ..."); |
rpc_SetErr(EMSGSIZE, "Reply RPC packet not enough buffer space ..."); |
return -1; |
return -1; |
} |
} |
if (len > ntohs(rpc->call_len) - sizeof(struct tagRPCCall)) { | if (len > ntohl(rpc->call_len) - sizeof(struct tagRPCCall)) { |
rpc_SetErr(EMSGSIZE, "Reply RPC packet is too short ..."); |
rpc_SetErr(EMSGSIZE, "Reply RPC packet is too short ..."); |
return -1; |
return -1; |
} |
} |