/* Helper function to send the header and then send the union packet */
static void send_smon_to_mon_pkt(SOCKET sock, gp_smon_to_mmon_packet_t* pkt)
{
send_fully(sock, &pkt->header, sizeof(gp_smon_to_mmon_header_t));
if (pkt->header.pkttype == GPMON_PKTTYPE_QEXEC) {
send_fully(sock, &pkt->u.qexec_packet.data, sizeof(qexec_packet_data_t) );
} else {
send_fully(sock, &pkt->u, get_size_by_pkttype_smon_to_mmon(pkt->header.pkttype));
}
TR2(("Sent packet of type %d to mmon\n", pkt->header.pkttype));
}
static jdwpTransportError
handshake(int fd, jlong timeout) {
const char *hello = "JDWP-Handshake";
char b[16];
int rv, helloLen, received;
if (timeout > 0) {
dbgsysConfigureBlocking(fd, JNI_FALSE);
}
helloLen = (int)strlen(hello);
received = 0;
while (received < helloLen) {
int n;
char *buf;
if (timeout > 0) {
rv = dbgsysPoll(fd, JNI_TRUE, JNI_FALSE, (long)timeout);
if (rv <= 0) {
setLastError(0, "timeout during handshake");
return JDWPTRANSPORT_ERROR_IO_ERROR;
}
}
buf = b;
buf += received;
n = recv_fully(fd, buf, helloLen-received);
if (n == 0) {
setLastError(0, "handshake failed - connection prematurally closed");
return JDWPTRANSPORT_ERROR_IO_ERROR;
}
if (n < 0) {
RETURN_IO_ERROR("recv failed during handshake");
}
received += n;
}
if (timeout > 0) {
dbgsysConfigureBlocking(fd, JNI_TRUE);
}
if (strncmp(b, hello, received) != 0) {
char msg[80+2*16];
b[received] = '\0';
/*
* We should really use snprintf here but it's not available on Windows.
* We can't use jio_snprintf without linking the transport against the VM.
*/
sprintf(msg, "handshake failed - received >%s< - expected >%s<", b, hello);
setLastError(0, msg);
return JDWPTRANSPORT_ERROR_IO_ERROR;
}
if (send_fully(fd, (char*)hello, helloLen) != helloLen) {
RETURN_IO_ERROR("send failed during handshake");
}
return JDWPTRANSPORT_ERROR_NONE;
}
static jdwpTransportError JNICALL
socketTransport_writePacket(jdwpTransportEnv* env, const jdwpPacket *packet)
{
jint len, data_len, id;
/*
* room for header and up to MAX_DATA_SIZE data bytes
*/
char header[HEADER_SIZE + MAX_DATA_SIZE];
jbyte *data;
/* packet can't be null */
if (packet == NULL) {
RETURN_ERROR(JDWPTRANSPORT_ERROR_ILLEGAL_ARGUMENT, "packet is NULL");
}
len = packet->type.cmd.len; /* includes header */
data_len = len - HEADER_SIZE;
/* bad packet */
if (data_len < 0) {
RETURN_ERROR(JDWPTRANSPORT_ERROR_ILLEGAL_ARGUMENT, "invalid length");
}
/* prepare the header for transmission */
len = (jint)dbgsysHostToNetworkLong(len);
id = (jint)dbgsysHostToNetworkLong(packet->type.cmd.id);
memcpy(header + 0, &len, 4);
memcpy(header + 4, &id, 4);
header[8] = packet->type.cmd.flags;
if (packet->type.cmd.flags & JDWPTRANSPORT_FLAGS_REPLY) {
jshort errorCode =
dbgsysHostToNetworkShort(packet->type.reply.errorCode);
memcpy(header + 9, &errorCode, 2);
} else {
header[9] = packet->type.cmd.cmdSet;
header[10] = packet->type.cmd.cmd;
}
data = packet->type.cmd.data;
/* Do one send for short packets, two for longer ones */
if (data_len <= MAX_DATA_SIZE) {
memcpy(header + HEADER_SIZE, data, data_len);
if (send_fully(socketFD, (char *)&header, HEADER_SIZE + data_len) !=
HEADER_SIZE + data_len) {
RETURN_IO_ERROR("send failed");
}
} else {
memcpy(header + HEADER_SIZE, data, MAX_DATA_SIZE);
if (send_fully(socketFD, (char *)&header, HEADER_SIZE + MAX_DATA_SIZE) !=
HEADER_SIZE + MAX_DATA_SIZE) {
RETURN_IO_ERROR("send failed");
}
/* Send the remaining data bytes right out of the data area. */
if (send_fully(socketFD, (char *)data + MAX_DATA_SIZE,
data_len - MAX_DATA_SIZE) != data_len - MAX_DATA_SIZE) {
RETURN_IO_ERROR("send failed");
}
}
return JDWPTRANSPORT_ERROR_NONE;
}
