int
hstcpcli::response_recv(size_t& num_flds_r)
{
if (error_code < 0) {
return error_code;
}
clear_error();
if (num_req_bufd > 0 || num_req_sent == 0 || num_req_rcvd > 0 ||
response_end_offset != 0) {
close();
return set_error(-1, "response_recv: protocol out of sync");
}
cur_row_offset = 0;
num_flds_r = num_flds = 0;
if (fd.get() < 0) {
return set_error(-1, "read: closed");
}
size_t offset = 0;
while (true) {
const char *const lbegin = readbuf.begin() + offset;
const char *const lend = readbuf.end();
const char *const nl = memchr_char(lbegin, '\n', lend - lbegin);
if (nl != 0) {
offset = (nl + 1) - readbuf.begin();
break;
}
if (read_more() <= 0) {
close();
return set_error(-1, "read: eof");
}
}
response_end_offset = offset;
--num_req_sent;
++num_req_rcvd;
char *start = readbuf.begin();
char *const finish = start + response_end_offset - 1;
const size_t resp_code = read_ui32(start, finish);
skip_one(start, finish);
num_flds_r = num_flds = read_ui32(start, finish);
if (resp_code != 0) {
skip_one(start, finish);
char *const err_begin = start;
read_token(start, finish);
char *const err_end = start;
std::string e = std::string(err_begin, err_end - err_begin);
if (e.empty()) {
e = "unknown_error";
}
return set_error(resp_code, e);
}
cur_row_offset = start - readbuf.begin();
DBG(fprintf(stderr, "[%s] ro=%zu eol=%zu\n",
std::string(readbuf.begin(), readbuf.begin() + response_end_offset)
.c_str(),
cur_row_offset, response_end_offset));
DBG(fprintf(stderr, "RES 0\n"));
return 0;
}
const string_ref *
hstcpcli::get_next_row()
{
if (num_flds == 0) {
DBG(fprintf(stderr, "GNR NF 0\n"));
return 0;
}
if (flds.size() < num_flds) {
flds.resize(num_flds);
}
char *start = readbuf.begin() + cur_row_offset;
char *const finish = readbuf.begin() + response_end_offset - 1;
if (start >= finish) { /* start[0] == nl */
DBG(fprintf(stderr, "GNR FIN 0 %p %p\n", start, finish));
return 0;
}
for (size_t i = 0; i < num_flds; ++i) {
skip_one(start, finish);
char *const fld_begin = start;
read_token(start, finish);
char *const fld_end = start;
char *wp = fld_begin;
if (is_null_expression(fld_begin, fld_end)) {
/* null */
flds[i] = string_ref();
} else {
unescape_string(wp, fld_begin, fld_end); /* in-place */
flds[i] = string_ref(fld_begin, wp);
}
}
cur_row_offset = start - readbuf.begin();
return &flds[0];
}
const string_ref *
hstcpcli::get_next_row_from_result(hstresult& result)
{
if (result.num_flds == 0 || result.flds.elements < result.num_flds) {
DBG(fprintf(stderr, "GNR NF 0\n"));
return 0;
}
char *start = result.readbuf.begin() + result.cur_row_offset;
char *const finish = result.readbuf.begin() + result.response_end_offset - 1;
if (start >= finish) { /* start[0] == nl */
DBG(fprintf(stderr, "GNR FIN 0 %p %p\n", start, finish));
return 0;
}
for (size_t i = 0; i < result.num_flds; ++i) {
skip_one(start, finish);
char *const fld_begin = start;
read_token(start, finish);
char *const fld_end = start;
char *wp = fld_begin;
if (is_null_expression(fld_begin, fld_end)) {
/* null */
((string_ref *) result.flds.buffer)[i] = string_ref();
} else {
unescape_string(wp, fld_begin, fld_end); /* in-place */
((string_ref *) result.flds.buffer)[i] = string_ref(fld_begin, wp);
}
}
result.cur_row_offset = start - result.readbuf.begin();
return (string_ref *) result.flds.buffer;
}
virtual void handle_movzx(UByte opcode, size_t word_size) {
UByte fault;
UByte modrm;
skip_one();
_scanner.get(&modrm);
fault = modify_rm_reg(modrm);
_scanner.seek(-1, scanner::SEEK_CUR);
_scanner.put(fault);
skip_modrm(fault, word_size);
}
virtual void handle_mov(UByte opcode, size_t word_size) {
switch (opcode) {
case 0x88:
case 0x8A:
case 0x89:
case 0x8E:
{
//
// Modify R/M and REG fields in the MOD R/M byte
//
UByte fault;
UByte modrm;
_scanner.get(&modrm);
switch (decode_modrm_mod(modrm)) {
case 0:
if (word_size == 4 && decode_modrm_rm(modrm) == 4) {
fault = modify_reg(modrm);
}
else if (decode_modrm_rm(modrm) == 5) {
fault = modify_reg(modrm);
}
else {
fault = modify_rm_reg(modrm);
}
break;
case 1:
if (word_size == 4 && decode_modrm_rm(modrm) == 4) {
fault = modify_reg(modrm);
}
else {
fault = modify_rm_reg(modrm);
}
break;
case 2:
if (word_size == 4 && decode_modrm_rm(modrm) == 4) {
fault = modify_reg(modrm);
}
else {
fault = modify_rm_reg(modrm);
}
break;
case 3:
fault = modify_rm_reg(modrm);
break;
default:
System.Print(System.WARN, "Unknown modrm");
return;
}
// Inject a fault
_scanner.seek(-1, scanner::SEEK_CUR);
_scanner.put(fault);
// OK. Let's work on the next instruction.
skip_modrm(fault, word_size);
break;
}
// [SKIP] Segment registers
case 0x8B:
case 0x8C:
{
UByte next;
_scanner.get(&next);
skip_modrm(next, word_size);
break;
}
// [SKIP] Immediate
case 0xC6:
{
UByte next;
_scanner.get(&next);
skip_modrm(next, word_size);
skip_one();
break;
}
// [SKIP] Immediate
case 0xC7:
{
UByte next;
_scanner.get(&next);
skip_modrm(next, word_size);
skip_word(word_size);
break;
}
// [SKIP] 'A' register (i.e. al, ax, eax)
case 0xA0:
case 0xA1:
case 0xA2:
case 0xA3:
{
skip_word(word_size);
break;
}
default:
{
// Move imm8 to r8
if (0xB0 <= opcode && opcode <= 0xB7) {
UByte fault = opcode;
while (fault == opcode) {
fault = 0xB0 | (static_cast<UByte>(rand()) & 0xF);
}
// Inject a fault
_scanner.seek(-1, scanner::SEEK_CUR);
_scanner.put(fault);
// OK. Work on the next instruction.
skip_one();
System.Print("FI: MOV(%.2X): Change opcode %.2X\n",
opcode, fault);
}
// Move imm16/32 to r16/32
else if (0xB8 <= opcode && opcode <= 0xBF) {
UByte fault = opcode;
while (fault == opcode) {
fault = 0xB8 | (static_cast<UByte>(rand()) & 0xF);
}
// Inject a fault
_scanner.seek(-1, scanner::SEEK_CUR);
_scanner.put(fault);
// OK. Work on the next instruction.
skip_word(word_size);
System.Print("FI: MOV(%.2X): Change opcode %.2X\n",
opcode, fault);
}
}
} // switch
}
int parse_star(GScanner *scan, struct cat_star *cats)
{
int havera = 0, havedec = 0, havename = 0, havemag = 0, haveeq = 0;
GTokenType tok;
do {
tok = g_scanner_get_next_token(scan);
// d3_printf("star ");
// print_token(scan, tok);
if (tok == ')')
continue;
if (tok != G_TOKEN_SYMBOL) {
// d3_printf("skip non-symbol\n");
if (tok == '(')
skip_list(scan);
else
skip_one(scan);
continue;
}
switch(intval(scan)) {
case SYM_RA:
tok = g_scanner_get_next_token(scan);
switch(tok) {
case G_TOKEN_STRING:
havera = !dms_to_degrees(stringval(scan),
&cats->ra);
cats->ra *= 15.0;
break;
case '-':
tok = g_scanner_get_next_token(scan);
if (tok != G_TOKEN_FLOAT)
break;
cats->ra = -floatval(scan);
havera = 1;
break;
case G_TOKEN_FLOAT:
cats->ra = floatval(scan);
havera = 1;
break;
case '(':
skip_list(scan);
break;
default:
break;
}
break;
case SYM_DEC:
tok = g_scanner_get_next_token(scan);
switch(tok) {
case G_TOKEN_STRING:
havedec = !dms_to_degrees(stringval(scan),
&cats->dec);
break;
case '-':
tok = g_scanner_get_next_token(scan);
if (tok != G_TOKEN_FLOAT)
break;
cats->dec = -floatval(scan);
havedec = 1;
break;
case G_TOKEN_FLOAT:
cats->dec = floatval(scan);
havedec = 1;
break;
case '(':
skip_list(scan);
break;
default:
break;
}
break;
case SYM_EQUINOX:
tok = g_scanner_get_next_token(scan);
switch(tok) {
case '-':
tok = g_scanner_get_next_token(scan);
if (tok != G_TOKEN_FLOAT)
break;
haveeq = 1;
cats->equinox = -floatval(scan);
break;
case G_TOKEN_FLOAT:
haveeq = 1;
cats->equinox = floatval(scan);
break;
case '(':
skip_list(scan);
break;
default:
break;
}
break;
case SYM_PERR:
tok = g_scanner_get_next_token(scan);
switch(tok) {
case '-':
tok = g_scanner_get_next_token(scan);
if (tok != G_TOKEN_FLOAT)
break;
cats->perr = -floatval(scan);
break;
case G_TOKEN_FLOAT:
cats->perr = floatval(scan);
break;
case '(':
skip_list(scan);
break;
default:
break;
}
break;
case SYM_MAG:
tok = g_scanner_get_next_token(scan);
switch(tok) {
case '-':
tok = g_scanner_get_next_token(scan);
if (tok != G_TOKEN_FLOAT)
break;
cats->mag = -floatval(scan);
havemag = 1;
break;
case G_TOKEN_FLOAT:
cats->mag = floatval(scan);
havemag = 1;
break;
case '(':
skip_list(scan);
break;
default:
break;
}
break;
case SYM_SKY:
tok = g_scanner_get_next_token(scan);
switch(tok) {
case '-':
tok = g_scanner_get_next_token(scan);
if (tok != G_TOKEN_FLOAT)
break;
cats->sky = -floatval(scan);
cats->flags |= INFO_SKY;
break;
case G_TOKEN_FLOAT:
cats->sky = floatval(scan);
cats->flags |= INFO_SKY;
break;
case '(':
skip_list(scan);
break;
default:
break;
}
break;
case SYM_DIFFAM:
tok = g_scanner_get_next_token(scan);
switch(tok) {
case '-':
tok = g_scanner_get_next_token(scan);
if (tok != G_TOKEN_FLOAT)
break;
cats->diffam = -floatval(scan);
cats->flags |= INFO_DIFFAM;
break;
case G_TOKEN_FLOAT:
cats->diffam = floatval(scan);
cats->flags |= INFO_DIFFAM;
break;
case '(':
skip_list(scan);
break;
default:
break;
}
break;
case SYM_RESIDUAL:
tok = g_scanner_get_next_token(scan);
switch(tok) {
case '-':
tok = g_scanner_get_next_token(scan);
if (tok != G_TOKEN_FLOAT)
break;
cats->residual = -floatval(scan);
cats->flags |= INFO_RESIDUAL;
break;
case G_TOKEN_FLOAT:
cats->residual = floatval(scan);
cats->flags |= INFO_RESIDUAL;
break;
case '(':
skip_list(scan);
break;
default:
break;
}
break;
case SYM_STDERR:
tok = g_scanner_get_next_token(scan);
switch(tok) {
case '-':
tok = g_scanner_get_next_token(scan);
if (tok != G_TOKEN_FLOAT)
break;
cats->std_err = -floatval(scan);
cats->flags |= INFO_STDERR;
break;
case G_TOKEN_FLOAT:
cats->std_err = floatval(scan);
cats->flags |= INFO_STDERR;
break;
case '(':
skip_list(scan);
break;
default:
break;
}
break;
case SYM_COMMENTS:
tok = g_scanner_get_next_token(scan);
switch(tok) {
case G_TOKEN_STRING:
cats->comments = strdup(stringval(scan));
break;
case '(':
skip_list(scan);
break;
default:
break;
}
break;
case SYM_SMAGS:
tok = g_scanner_get_next_token(scan);
switch(tok) {
case G_TOKEN_STRING:
cats->smags = strdup(stringval(scan));
break;
case '(':
skip_list(scan);
break;
default:
break;
}
break;
case SYM_IMAGS:
tok = g_scanner_get_next_token(scan);
switch(tok) {
case G_TOKEN_STRING:
cats->imags = strdup(stringval(scan));
break;
case '(':
skip_list(scan);
break;
default:
break;
}
break;
case SYM_NAME:
tok = g_scanner_get_next_token(scan);
switch(tok) {
case G_TOKEN_STRING:
strncpy(cats->name, stringval(scan), CAT_STAR_NAME_SZ);
havename = 1;
break;
case '(':
skip_list(scan);
break;
default:
break;
}
break;
case SYM_TYPE:
tok = g_scanner_get_next_token(scan);
switch(tok) {
case G_TOKEN_SYMBOL:
switch(intval(scan)) {
case SYM_STD:
cats->flags = (cats->flags & ~CAT_STAR_TYPE_MASK)
| CAT_STAR_TYPE_APSTD;
cats->flags &= ~CAT_VARIABLE;
break;
case SYM_TGT:
case SYM_TARGET:
cats->flags = (cats->flags & ~CAT_STAR_TYPE_MASK)
| CAT_STAR_TYPE_APSTAR;
break;
case SYM_FIELD:
cats->flags = (cats->flags & ~CAT_STAR_TYPE_MASK)
| CAT_STAR_TYPE_SREF;
break;
case SYM_CATALOG:
cats->flags = (cats->flags & ~CAT_STAR_TYPE_MASK)
| CAT_STAR_TYPE_CAT;
break;
default:
break;
}
break;
case '(':
skip_list(scan);
break;
default:
break;
}
break;
case SYM_FLAGS:
tok = g_scanner_get_next_token(scan);
switch(tok) {
case '(':
cats->flags |= get_flags_from_list(scan);
break;
default:
break;
}
break;
case SYM_NOISE:
tok = g_scanner_get_next_token(scan);
switch(tok) {
case '(':
get_noise_from_rcp(scan, cats);
break;
default:
break;
}
break;
case SYM_CENTROID:
tok = g_scanner_get_next_token(scan);
switch(tok) {
case '(':
get_centroid_from_rcp(scan, cats);
break;
default:
break;
}
break;
default:
tok = g_scanner_get_next_token(scan);
switch(tok) {
case '(':
skip_list(scan);
break;
default:
break;
}
break;
}
} while (tok != ')' && tok != G_TOKEN_EOF);
if (!havemag || cats->mag == 0.0) {
// mag_from_smags(cats);
}
if (!haveeq)
cats->equinox = 2000.0;
if (havedec && havera && havename)
return 0;
else
return -1;
}
int
hstcpcli::response_recv(size_t& num_flds_r)
{
if (error_code < 0) {
return error_code;
}
clear_error();
if (num_req_bufd > 0 || num_req_sent == 0 || num_req_rcvd > 0 ||
response_end_offset != 0) {
close();
return set_error(-1, "response_recv: protocol out of sync");
}
cur_row_offset = 0;
num_flds_r = num_flds = 0;
if (fd.get() < 0) {
return set_error(-1, "read: closed");
}
size_t offset = 0;
while (true) {
const char *const lbegin = readbuf.begin() + offset;
const char *const lend = readbuf.end();
if (lbegin < lend)
{
const char *const nl = memchr_char(lbegin, '\n', lend - lbegin);
if (nl != 0) {
offset += (nl + 1) - lbegin;
break;
}
offset += lend - lbegin;
}
if (read_more() <= 0) {
close();
error_code = -1;
return error_code;
}
}
response_end_offset = offset;
--num_req_sent;
++num_req_rcvd;
char *start = readbuf.begin();
char *const finish = start + response_end_offset - 1;
const size_t resp_code = read_ui32(start, finish);
skip_one(start, finish);
num_flds_r = num_flds = read_ui32(start, finish);
if (resp_code != 0) {
skip_one(start, finish);
char *const err_begin = start;
read_token(start, finish);
char *const err_end = start;
String e = String(err_begin, err_end - err_begin, &my_charset_bin);
if (!e.length()) {
e = String("unknown_error", &my_charset_bin);
}
return set_error(resp_code, e);
}
cur_row_offset = start - readbuf.begin();
DBG(fprintf(stderr, "[%s] ro=%zu eol=%zu\n",
String(readbuf.begin(), readbuf.begin() + response_end_offset)
.c_str(),
cur_row_offset, response_end_offset));
DBG(fprintf(stderr, "RES 0\n"));
if (flds.max_element < num_flds)
{
if (allocate_dynamic(&flds, num_flds))
return set_error(-1, "out of memory");
}
flds.elements = num_flds;
return 0;
}
