/*------------------------------------------------------------*/
void
vrml_viewpoint (vector3 *pos, vector3 *ori, double rot,
double fov, char *descr)
{
/* pre */
assert (pos);
assert (fov >= 0.0);
indent_newline();
vrml_node ("Viewpoint");
indent_string ("position");
vrml_v3 (pos);
if (ori) {
indent_newline();
indent_string ("orientation");
vrml_v3_g (ori);
vrml_g (rot);
}
if (fov > 0.0) {
indent_newline();
indent_string ("fieldOfView");
vrml_g (fov);
}
if (descr) {
indent_newline();
indent_string ("description");
vrml_s_quoted (descr);
}
vrml_finish_node();
}
SQRESULT tostring(HSQUIRRELVM sqvm) {
sqxtd::vm vm{sqvm};
native_string result("{\n");
try {
sqxtd::table table
{validate<sqxtd::table>(vm.stack.at(-1))
.with_error(_SC("table::tostring: invalid receiver of type `%s` "
"(are you calling the _tostring() metamethod on "
"the `table` default delegate directly?)"),
vm.stack.typename_at(-1)).value()};
for (auto &pair : table) {
auto key_value = format_key_value(pair.first.tostring(), quoted(pair.second).tostring());
result += indent_string(key_value);
result += "\n";
}
} catch (object::invalid_cast) {
return SQ_ERROR;
}
result += "}";
vm.stack.push(result);
return 1;
}
int PulseBlasterDDSIIIProgram::write_to_file(FILE* out, size_t indent) const {
std::string indent_string(indent,' ');
fprintf(out,"%s<PulseBlasterDDSIIIProgram>\n",indent_string.c_str());
if (!frequency_registers.empty()) {
fprintf(out,"%s <frequencies>",indent_string.c_str());
for (size_t i=0; i<frequency_registers.size(); i++)
fprintf(out," %g",frequency_registers[i]);
fprintf(out," </frequencies>\n");
}
if (!rx_phase_registers.empty()) {
fprintf(out,"%s <rxphases>",indent_string.c_str());
for (size_t i=0;i<rx_phase_registers.size();i++)
fprintf(out," %g",rx_phase_registers[i]);
fprintf(out," </rxphases>\n");
}
if (!tx_phase_registers.empty()) {
fprintf(out,"%s <txphases>",indent_string.c_str());
for (size_t i=0;i<tx_phase_registers.size();i++)
fprintf(out," %g",tx_phase_registers[i]);
fprintf(out," </txphases>\n");
}
for(const_iterator i=begin();i!=end();++i) {
(**i).write_to_file(out,indent+2);
}
fprintf(out,"%s</PulseBlasterDDSIIIProgram>\n",indent_string.c_str());
return 1;
}
/*------------------------------------------------------------*/
void
vrml_bbox (vector3 *center, vector3 *size)
{
/* pre */
assert (center);
assert (size);
if (size->x <= 0.0) return;
if (size->y <= 0.0) return;
if (size->z <= 0.0) return;
indent_newline();
indent_string ("bboxCenter");
vrml_v3_g (center);
indent_newline();
indent_string ("bboxSize");
vrml_v3_g (size);
}
/*------------------------------------------------------------*/
void
vrml_navigationinfo (double speed, char *type)
{
/* pre */
assert (speed > 0.0);
indent_newline();
vrml_node ("NavigationInfo");
if (speed != 1.0) {
indent_string ("speed");
vrml_g (speed);
}
if (type) {
indent_newline_conditional();
indent_string ("type");
indent_string (type);
}
vrml_finish_node();
}
/*------------------------------------------------------------*/
void
vrml_fog (int type_exp, double r, colour *c)
{
/* pre */
assert (r > 0.0);
assert (c);
indent_newline();
vrml_node ("Fog");
indent_string ("fogType");
if (type_exp) {
vrml_s_quoted ("EXPONENTIAL");
} else {
vrml_s_quoted ("LINEAR");
}
indent_newline();
indent_string ("visibilityRange");
vrml_g (r);
indent_newline();
indent_string ("color "); /* last blank char needed */
vrml_colour (c);
vrml_finish_node();
}
/*
* Print a single PDU.
*/
static void
rpki_rtr_pdu_print (netdissect_options *ndo, const u_char *tptr, u_int indent)
{
const rpki_rtr_pdu *pdu_header;
u_int pdu_type, pdu_len, hexdump;
const u_char *msg;
pdu_header = (const rpki_rtr_pdu *)tptr;
pdu_type = pdu_header->pdu_type;
pdu_len = EXTRACT_32BITS(pdu_header->length);
ND_TCHECK2(*tptr, pdu_len);
hexdump = FALSE;
ND_PRINT((ndo, "%sRPKI-RTRv%u, %s PDU (%u), length: %u",
indent_string(8),
pdu_header->version,
tok2str(rpki_rtr_pdu_values, "Unknown", pdu_type),
pdu_type, pdu_len));
switch (pdu_type) {
/*
* The following PDUs share the message format.
*/
case RPKI_RTR_SERIAL_NOTIFY_PDU:
case RPKI_RTR_SERIAL_QUERY_PDU:
case RPKI_RTR_END_OF_DATA_PDU:
msg = (const u_char *)(pdu_header + 1);
ND_PRINT((ndo, "%sSession ID: 0x%04x, Serial: %u",
indent_string(indent+2),
EXTRACT_16BITS(pdu_header->u.session_id),
EXTRACT_32BITS(msg)));
break;
/*
* The following PDUs share the message format.
*/
case RPKI_RTR_RESET_QUERY_PDU:
case RPKI_RTR_CACHE_RESET_PDU:
/*
* Zero payload PDUs.
*/
break;
case RPKI_RTR_CACHE_RESPONSE_PDU:
ND_PRINT((ndo, "%sSession ID: 0x%04x",
indent_string(indent+2),
EXTRACT_16BITS(pdu_header->u.session_id)));
break;
case RPKI_RTR_IPV4_PREFIX_PDU:
{
const rpki_rtr_pdu_ipv4_prefix *pdu;
pdu = (const rpki_rtr_pdu_ipv4_prefix *)tptr;
ND_PRINT((ndo, "%sIPv4 Prefix %s/%u-%u, origin-as %u, flags 0x%02x",
indent_string(indent+2),
ipaddr_string(ndo, pdu->prefix),
pdu->prefix_length, pdu->max_length,
EXTRACT_32BITS(pdu->as), pdu->flags));
}
break;
case RPKI_RTR_IPV6_PREFIX_PDU:
{
const rpki_rtr_pdu_ipv6_prefix *pdu;
pdu = (const rpki_rtr_pdu_ipv6_prefix *)tptr;
ND_PRINT((ndo, "%sIPv6 Prefix %s/%u-%u, origin-as %u, flags 0x%02x",
indent_string(indent+2),
ip6addr_string(ndo, pdu->prefix),
pdu->prefix_length, pdu->max_length,
EXTRACT_32BITS(pdu->as), pdu->flags));
}
break;
case RPKI_RTR_ERROR_REPORT_PDU:
{
const rpki_rtr_pdu_error_report *pdu;
u_int encapsulated_pdu_length, text_length, tlen, error_code;
pdu = (const rpki_rtr_pdu_error_report *)tptr;
encapsulated_pdu_length = EXTRACT_32BITS(pdu->encapsulated_pdu_length);
ND_TCHECK2(*tptr, encapsulated_pdu_length);
tlen = pdu_len;
error_code = EXTRACT_16BITS(pdu->pdu_header.u.error_code);
ND_PRINT((ndo, "%sError code: %s (%u), Encapsulated PDU length: %u",
indent_string(indent+2),
tok2str(rpki_rtr_error_codes, "Unknown", error_code),
error_code, encapsulated_pdu_length));
tptr += sizeof(*pdu);
tlen -= sizeof(*pdu);
/*
* Recurse if there is an encapsulated PDU.
*/
if (encapsulated_pdu_length &&
(encapsulated_pdu_length <= tlen)) {
ND_PRINT((ndo, "%s-----encapsulated PDU-----", indent_string(indent+4)));
rpki_rtr_pdu_print(ndo, tptr, indent+2);
}
tptr += encapsulated_pdu_length;
tlen -= encapsulated_pdu_length;
/*
* Extract, trail-zero and print the Error message.
*/
text_length = 0;
if (tlen > 4) {
text_length = EXTRACT_32BITS(tptr);
tptr += 4;
tlen -= 4;
}
ND_TCHECK2(*tptr, text_length);
if (text_length && (text_length <= tlen )) {
ND_PRINT((ndo, "%sError text: ", indent_string(indent+2)));
fn_printn(ndo, tptr, text_length, ndo->ndo_snapend);
}
}
break;
default:
/*
* Unknown data, please hexdump.
*/
hexdump = TRUE;
}
/* do we also want to see a hex dump ? */
if (ndo->ndo_vflag > 1 || (ndo->ndo_vflag && hexdump)) {
print_unknown_data(ndo,tptr,"\n\t ", pdu_len);
}
return;
trunc:
ND_PRINT((ndo, "|trunc"));
return;
}
/*
* Print a single PDU.
*/
static void
rpki_rtr_pdu_print (packetbody_t tptr, u_int indent)
{
__capability const rpki_rtr_pdu *pdu_header;
u_int pdu_type, pdu_len, hexdump;
packetbody_t msg;
pdu_header = (__capability const rpki_rtr_pdu *)tptr;
pdu_type = pdu_header->pdu_type;
pdu_len = EXTRACT_32BITS(pdu_header->length);
hexdump = FALSE;
printf("%sRPKI-RTRv%u, %s PDU (%u), length: %u",
indent_string(8),
pdu_header->version,
tok2str(rpki_rtr_pdu_values, "Unknown", pdu_type),
pdu_type, pdu_len);
switch (pdu_type) {
/*
* The following PDUs share the message format.
*/
case RPKI_RTR_SERIAL_NOTIFY_PDU:
case RPKI_RTR_SERIAL_QUERY_PDU:
case RPKI_RTR_END_OF_DATA_PDU:
msg = (packetbody_t)(pdu_header + 1);
printf("%sSession ID: 0x%04x, Serial: %u",
indent_string(indent+2),
EXTRACT_16BITS(pdu_header->u.session_id),
EXTRACT_32BITS(msg));
break;
/*
* The following PDUs share the message format.
*/
case RPKI_RTR_RESET_QUERY_PDU:
case RPKI_RTR_CACHE_RESET_PDU:
/*
* Zero payload PDUs.
*/
break;
case RPKI_RTR_CACHE_RESPONSE_PDU:
printf("%sSession ID: 0x%04x",
indent_string(indent+2),
EXTRACT_16BITS(pdu_header->u.session_id));
break;
case RPKI_RTR_IPV4_PREFIX_PDU:
{
__capability const rpki_rtr_pdu_ipv4_prefix *pdu;
pdu = (__capability const rpki_rtr_pdu_ipv4_prefix *)tptr;
printf("%sIPv4 Prefix %s/%u-%u, origin-as %u, flags 0x%02x",
indent_string(indent+2),
ipaddr_string(pdu->prefix),
pdu->prefix_length, pdu->max_length,
EXTRACT_32BITS(pdu->as), pdu->flags);
}
break;
#ifdef INET6
case RPKI_RTR_IPV6_PREFIX_PDU:
{
__capability const rpki_rtr_pdu_ipv6_prefix *pdu;
pdu = (__capability const rpki_rtr_pdu_ipv6_prefix *)tptr;
printf("%sIPv6 Prefix %s/%u-%u, origin-as %u, flags 0x%02x",
indent_string(indent+2),
ip6addr_string(pdu->prefix),
pdu->prefix_length, pdu->max_length,
EXTRACT_32BITS(pdu->as), pdu->flags);
}
break;
#endif
case RPKI_RTR_ERROR_REPORT_PDU:
{
__capability const rpki_rtr_pdu_error_report *pdu;
u_int encapsulated_pdu_length, text_length, tlen, error_code;
u_char buf[80];
pdu = (__capability const rpki_rtr_pdu_error_report *)tptr;
encapsulated_pdu_length = EXTRACT_32BITS(pdu->encapsulated_pdu_length);
tlen = pdu_len;
error_code = EXTRACT_16BITS(pdu->pdu_header.u.error_code);
printf("%sError code: %s (%u), Encapsulated PDU length: %u",
indent_string(indent+2),
tok2str(rpki_rtr_error_codes, "Unknown", error_code),
error_code, encapsulated_pdu_length);
tptr += sizeof(*pdu);
tlen -= sizeof(*pdu);
/*
* Recurse if there is an encapsulated PDU.
*/
if (encapsulated_pdu_length &&
(encapsulated_pdu_length <= tlen)) {
printf("%s-----encapsulated PDU-----", indent_string(indent+4));
rpki_rtr_pdu_print(tptr, indent+2);
}
tptr += encapsulated_pdu_length;
tlen -= encapsulated_pdu_length;
/*
* Extract, trail-zero and print the Error message.
*/
text_length = 0;
if (tlen > 4) {
text_length = EXTRACT_32BITS(tptr);
tptr += 4;
tlen -= 4;
}
if (text_length && (text_length <= tlen )) {
p_memcpy_from_packet(buf, tptr, MIN(sizeof(buf)-1, text_length));
buf[text_length] = '\0';
printf("%sError text: %s", indent_string(indent+2), buf);
}
}
break;
default:
/*
* Unknown data, please hexdump.
*/
hexdump = TRUE;
}
/* do we also want to see a hex dump ? */
if (vflag > 1 || (vflag && hexdump)) {
print_unknown_data(tptr,"\n\t ", pdu_len);
}
}
/*
* Print a single PDU.
*/
static u_int
rpki_rtr_pdu_print(netdissect_options *ndo, const u_char *tptr, const u_int len,
const u_char recurse, const u_int indent)
{
const rpki_rtr_pdu *pdu_header;
u_int pdu_type, pdu_len, hexdump;
const u_char *msg;
/* Protocol Version */
ND_TCHECK_1(tptr);
if (GET_U_1(tptr) != 0) {
/* Skip the rest of the input buffer because even if this is
* a well-formed PDU of a future RPKI-Router protocol version
* followed by a well-formed PDU of RPKI-Router protocol
* version 0, there is no way to know exactly how to skip the
* current PDU.
*/
ND_PRINT("%sRPKI-RTRv%u (unknown)", indent_string(8), GET_U_1(tptr));
return len;
}
if (len < sizeof(rpki_rtr_pdu)) {
ND_PRINT("(%u bytes is too few to decode)", len);
goto invalid;
}
ND_TCHECK_LEN(tptr, sizeof(rpki_rtr_pdu));
pdu_header = (const rpki_rtr_pdu *)tptr;
pdu_type = pdu_header->pdu_type;
pdu_len = GET_BE_U_4(pdu_header->length);
/* Do not check bounds with pdu_len yet, do it in the case blocks
* below to make it possible to decode at least the beginning of
* a truncated Error Report PDU or a truncated encapsulated PDU.
*/
hexdump = FALSE;
ND_PRINT("%sRPKI-RTRv%u, %s PDU (%u), length: %u",
indent_string(8),
pdu_header->version,
tok2str(rpki_rtr_pdu_values, "Unknown", pdu_type),
pdu_type, pdu_len);
if (pdu_len < sizeof(rpki_rtr_pdu) || pdu_len > len)
goto invalid;
switch (pdu_type) {
/*
* The following PDUs share the message format.
*/
case RPKI_RTR_SERIAL_NOTIFY_PDU:
case RPKI_RTR_SERIAL_QUERY_PDU:
case RPKI_RTR_END_OF_DATA_PDU:
if (pdu_len != sizeof(rpki_rtr_pdu) + 4)
goto invalid;
ND_TCHECK_LEN(tptr, pdu_len);
msg = (const u_char *)(pdu_header + 1);
ND_PRINT("%sSession ID: 0x%04x, Serial: %u",
indent_string(indent+2),
GET_BE_U_2(pdu_header->u.session_id),
GET_BE_U_4(msg));
break;
/*
* The following PDUs share the message format.
*/
case RPKI_RTR_RESET_QUERY_PDU:
case RPKI_RTR_CACHE_RESET_PDU:
if (pdu_len != sizeof(rpki_rtr_pdu))
goto invalid;
/* no additional boundary to check */
/*
* Zero payload PDUs.
*/
break;
case RPKI_RTR_CACHE_RESPONSE_PDU:
if (pdu_len != sizeof(rpki_rtr_pdu))
goto invalid;
/* no additional boundary to check */
ND_PRINT("%sSession ID: 0x%04x",
indent_string(indent+2),
GET_BE_U_2(pdu_header->u.session_id));
break;
case RPKI_RTR_IPV4_PREFIX_PDU:
{
const rpki_rtr_pdu_ipv4_prefix *pdu;
if (pdu_len != sizeof(rpki_rtr_pdu) + 12)
goto invalid;
ND_TCHECK_LEN(tptr, pdu_len);
pdu = (const rpki_rtr_pdu_ipv4_prefix *)tptr;
ND_PRINT("%sIPv4 Prefix %s/%u-%u, origin-as %u, flags 0x%02x",
indent_string(indent+2),
ipaddr_string(ndo, pdu->prefix),
pdu->prefix_length, pdu->max_length,
GET_BE_U_4(pdu->as), pdu->flags);
}
break;
case RPKI_RTR_IPV6_PREFIX_PDU:
{
const rpki_rtr_pdu_ipv6_prefix *pdu;
if (pdu_len != sizeof(rpki_rtr_pdu) + 24)
goto invalid;
ND_TCHECK_LEN(tptr, pdu_len);
pdu = (const rpki_rtr_pdu_ipv6_prefix *)tptr;
ND_PRINT("%sIPv6 Prefix %s/%u-%u, origin-as %u, flags 0x%02x",
indent_string(indent+2),
ip6addr_string(ndo, pdu->prefix),
pdu->prefix_length, pdu->max_length,
GET_BE_U_4(pdu->as), pdu->flags);
}
break;
case RPKI_RTR_ERROR_REPORT_PDU:
{
const rpki_rtr_pdu_error_report *pdu;
u_int encapsulated_pdu_length, text_length, tlen, error_code;
tlen = sizeof(rpki_rtr_pdu);
/* Do not test for the "Length of Error Text" data element yet. */
if (pdu_len < tlen + 4)
goto invalid;
ND_TCHECK_LEN(tptr, tlen + 4);
/* Safe up to and including the "Length of Encapsulated PDU"
* data element, more data elements may be present.
*/
pdu = (const rpki_rtr_pdu_error_report *)tptr;
encapsulated_pdu_length = GET_BE_U_4(pdu->encapsulated_pdu_length);
tlen += 4;
error_code = GET_BE_U_2(pdu->pdu_header.u.error_code);
ND_PRINT("%sError code: %s (%u), Encapsulated PDU length: %u",
indent_string(indent+2),
tok2str(rpki_rtr_error_codes, "Unknown", error_code),
error_code, encapsulated_pdu_length);
if (encapsulated_pdu_length) {
/* Section 5.10 of RFC 6810 says:
* "An Error Report PDU MUST NOT be sent for an Error Report PDU."
*
* However, as far as the protocol encoding goes Error Report PDUs can
* happen to be nested in each other, however many times, in which case
* the decoder should still print such semantically incorrect PDUs.
*
* That said, "the Erroneous PDU field MAY be truncated" (ibid), thus
* to keep things simple this implementation decodes only the two
* outermost layers of PDUs and makes bounds checks in the outer and
* the inner PDU independently.
*/
if (pdu_len < tlen + encapsulated_pdu_length)
goto invalid;
if (! recurse) {
ND_TCHECK_LEN(tptr, tlen + encapsulated_pdu_length);
}
else {
ND_PRINT("%s-----encapsulated PDU-----", indent_string(indent+4));
rpki_rtr_pdu_print(ndo, tptr + tlen,
encapsulated_pdu_length, 0, indent + 2);
}
tlen += encapsulated_pdu_length;
}
if (pdu_len < tlen + 4)
goto invalid;
ND_TCHECK_LEN(tptr, tlen + 4);
/* Safe up to and including the "Length of Error Text" data element,
* one more data element may be present.
*/
/*
* Extract, trail-zero and print the Error message.
*/
text_length = GET_BE_U_4(tptr + tlen);
tlen += 4;
if (text_length) {
if (pdu_len < tlen + text_length)
goto invalid;
/* nd_printn() makes the bounds check */
ND_PRINT("%sError text: ", indent_string(indent+2));
if (nd_printn(ndo, tptr + tlen, text_length, ndo->ndo_snapend))
goto trunc;
}
}
break;
default:
ND_TCHECK_LEN(tptr, pdu_len);
/*
* Unknown data, please hexdump.
*/
hexdump = TRUE;
}
/* do we also want to see a hex dump ? */
if (ndo->ndo_vflag > 1 || (ndo->ndo_vflag && hexdump)) {
print_unknown_data(ndo,tptr,"\n\t ", pdu_len);
}
return pdu_len;
invalid:
nd_print_invalid(ndo);
ND_TCHECK_LEN(tptr, len);
return len;
trunc:
nd_print_trunc(ndo);
return len;
}
static GString *
g_menu_markup_print_string (GString *string,
GMenuModel *model,
gint indent,
gint tabstop)
{
gboolean need_nl = FALSE;
gint i, n;
if G_UNLIKELY (string == NULL)
string = g_string_new (NULL);
n = g_menu_model_get_n_items (model);
for (i = 0; i < n; i++)
{
GMenuAttributeIter *attr_iter;
GMenuLinkIter *link_iter;
GString *contents;
GString *attrs;
attr_iter = g_menu_model_iterate_item_attributes (model, i);
link_iter = g_menu_model_iterate_item_links (model, i);
contents = g_string_new (NULL);
attrs = g_string_new (NULL);
while (g_menu_attribute_iter_next (attr_iter))
{
const char *name = g_menu_attribute_iter_get_name (attr_iter);
GVariant *value = g_menu_attribute_iter_get_value (attr_iter);
if (g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
{
gchar *str;
str = g_markup_printf_escaped (" %s='%s'", name, g_variant_get_string (value, NULL));
g_string_append (attrs, str);
g_free (str);
}
else
{
gchar *printed;
gchar *str;
const gchar *type;
printed = g_variant_print (value, TRUE);
type = g_variant_type_peek_string (g_variant_get_type (value));
str = g_markup_printf_escaped ("<attribute name='%s' type='%s'>%s</attribute>\n", name, type, printed);
indent_string (contents, indent + tabstop);
g_string_append (contents, str);
g_free (printed);
g_free (str);
}
g_variant_unref (value);
}
g_object_unref (attr_iter);
while (g_menu_link_iter_next (link_iter))
{
const gchar *name = g_menu_link_iter_get_name (link_iter);
GMenuModel *menu = g_menu_link_iter_get_value (link_iter);
gchar *str;
if (contents->str[0])
g_string_append_c (contents, '\n');
str = g_markup_printf_escaped ("<link name='%s'>\n", name);
indent_string (contents, indent + tabstop);
g_string_append (contents, str);
g_free (str);
g_menu_markup_print_string (contents, menu, indent + 2 * tabstop, tabstop);
indent_string (contents, indent + tabstop);
g_string_append (contents, "</link>\n");
g_object_unref (menu);
}
g_object_unref (link_iter);
if (contents->str[0])
{
indent_string (string, indent);
g_string_append_printf (string, "<item%s>\n", attrs->str);
g_string_append (string, contents->str);
indent_string (string, indent);
g_string_append (string, "</item>\n");
need_nl = TRUE;
}
else
{
if (need_nl)
g_string_append_c (string, '\n');
indent_string (string, indent);
g_string_append_printf (string, "<item%s/>\n", attrs->str);
need_nl = FALSE;
}
g_string_free (contents, TRUE);
g_string_free (attrs, TRUE);
}
return string;
}