static int
parse_actions(void)
{
struct ds in;
ds_init(&in);
vlog_set_levels_from_string_assert("odp_util:console:dbg");
while (!ds_get_test_line(&in, stdin)) {
struct ofpbuf odp_actions;
struct ds out;
int error;
/* Convert string to OVS DP actions. */
ofpbuf_init(&odp_actions, 0);
error = odp_actions_from_string(ds_cstr(&in), NULL, &odp_actions);
if (error) {
printf("odp_actions_from_string: error\n");
goto next;
}
/* Convert odp_actions back to string. */
ds_init(&out);
format_odp_actions(&out, odp_actions.data, odp_actions.size);
puts(ds_cstr(&out));
ds_destroy(&out);
next:
ofpbuf_uninit(&odp_actions);
}
ds_destroy(&in);
return 0;
}
int
main(void)
{
struct ds in;
ds_init(&in);
while (!ds_get_line(&in, stdin)) {
struct ofpbuf odp_key;
struct flow flow;
struct ds out;
int error;
char *s;
/* Delete comments, skip blank lines. */
s = ds_cstr(&in);
if (*s == '#') {
puts(s);
continue;
}
if (strchr(s, '#')) {
*strchr(s, '#') = '\0';
}
if (s[strspn(s, " ")] == '\0') {
putchar('\n');
continue;
}
/* Convert string to OVS DP key. */
ofpbuf_init(&odp_key, 0);
error = odp_flow_key_from_string(ds_cstr(&in), &odp_key);
if (error) {
printf("odp_flow_key_from_string: error\n");
goto next;
}
/* Convert odp_key to flow. */
error = odp_flow_key_to_flow(odp_key.data, odp_key.size, &flow);
if (error) {
printf("odp_flow_key_to_flow: error\n");
goto next;
}
/* Convert cls_rule back to odp_key. */
ofpbuf_uninit(&odp_key);
ofpbuf_init(&odp_key, 0);
odp_flow_key_from_flow(&odp_key, &flow);
/* Convert odp_key to string. */
ds_init(&out);
odp_flow_key_format(odp_key.data, odp_key.size, &out);
puts(ds_cstr(&out));
ds_destroy(&out);
next:
ofpbuf_uninit(&odp_key);
}
ds_destroy(&in);
return 0;
}
static void IntrospectArguments(adbus_Member* m, d_String* out)
{
size_t argi = 0;
const char* arg = ds_cstr(&m->argsig);
while (arg && *arg) {
const char* next = adbus_nextarg(arg);
ds_cat(out, "\t\t\t<arg type=\"");
ds_cat_n(out, arg, next - arg);
if (argi < dv_size(&m->arguments)) {
ds_cat(out, "\" name=\"");
ds_cat(out, dv_a(&m->arguments, argi));
}
ds_cat(out, "\"/>\n");
arg = next;
argi++;
}
assert(argi >= dv_size(&m->arguments));
argi = 0;
arg = ds_cstr(&m->retsig);
while (arg && *arg) {
const char* next = adbus_nextarg(arg);
ds_cat(out, "\t\t\t<arg type=\"");
ds_cat_n(out, arg, next - arg);
if (argi < dv_size(&m->returns)) {
ds_cat(out, "\" name=\"");
ds_cat(out, dv_a(&m->returns, argi));
}
ds_cat(out, "\" direction=\"out\"/>\n");
arg = next;
argi++;
}
assert(argi >= dv_size(&m->returns));
}
static void
test_lex(const char *input)
{
struct ds output;
ds_init(&output);
struct lexer lexer;
lexer_init(&lexer, input);
ds_clear(&output);
while (lexer_get(&lexer) != LEX_T_END) {
size_t len = output.length;
lex_token_format(&lexer.token, &output);
/* Check that the formatted version can really be parsed back
* losslessly. */
if (lexer.token.type != LEX_T_ERROR) {
const char *s = ds_cstr(&output) + len;
struct lexer l2;
lexer_init(&l2, s);
lexer_get(&l2);
compare_token(&lexer.token, &l2.token);
lexer_destroy(&l2);
}
ds_put_char(&output, ' ');
}
lexer_destroy(&lexer);
ds_chomp(&output, ' ');
puts(ds_cstr(&output));
ds_destroy(&output);
}
/* Parse all the labels for the VAR_CNT variables in VARS and add
the specified labels to those variables. */
static int
get_label (struct lexer *lexer, struct variable **vars, size_t var_cnt,
const char *dict_encoding)
{
/* Parse all the labels and add them to the variables. */
do
{
enum { MAX_LABEL_LEN = 255 };
int width = var_get_width (vars[0]);
union value value;
struct string label;
size_t trunc_len;
size_t i;
/* Set value. */
value_init (&value, width);
if (!parse_value (lexer, &value, vars[0]))
{
value_destroy (&value, width);
return 0;
}
lex_match (lexer, T_COMMA);
/* Set label. */
if (lex_token (lexer) != T_ID && !lex_force_string (lexer))
{
value_destroy (&value, width);
return 0;
}
ds_init_substring (&label, lex_tokss (lexer));
trunc_len = utf8_encoding_trunc_len (ds_cstr (&label), dict_encoding,
MAX_LABEL_LEN);
if (ds_length (&label) > trunc_len)
{
msg (SW, _("Truncating value label to %d bytes."), MAX_LABEL_LEN);
ds_truncate (&label, trunc_len);
}
for (i = 0; i < var_cnt; i++)
var_replace_value_label (vars[i], &value, ds_cstr (&label));
ds_destroy (&label);
value_destroy (&value, width);
lex_get (lexer);
lex_match (lexer, T_COMMA);
}
while (lex_token (lexer) != T_SLASH && lex_token (lexer) != T_ENDCMD);
return 1;
}
char *
process_escape_args(char **argv)
{
struct ds ds = DS_EMPTY_INITIALIZER;
char **argp;
for (argp = argv; *argp; argp++) {
const char *arg = *argp;
const char *p;
if (argp != argv) {
ds_put_char(&ds, ' ');
}
if (arg[strcspn(arg, " \t\r\n\v\\\'\"")]) {
ds_put_char(&ds, '"');
for (p = arg; *p; p++) {
if (*p == '\\' || *p == '\"') {
ds_put_char(&ds, '\\');
}
ds_put_char(&ds, *p);
}
ds_put_char(&ds, '"');
} else {
ds_put_cstr(&ds, arg);
}
}
return ds_cstr(&ds);
}
/* Given 'status', which is a process status in the form reported by waitpid(2)
* and returned by process_status(), returns a string describing how the
* process terminated. The caller is responsible for freeing the string when
* it is no longer needed. */
char *
process_status_msg(int status)
{
struct ds ds = DS_EMPTY_INITIALIZER;
if (WIFEXITED(status)) {
ds_put_format(&ds, "exit status %d", WEXITSTATUS(status));
} else if (WIFSIGNALED(status) || WIFSTOPPED(status)) {
int signr = WIFSIGNALED(status) ? WTERMSIG(status) : WSTOPSIG(status);
const char *name = NULL;
#ifdef HAVE_STRSIGNAL
name = strsignal(signr);
#endif
ds_put_format(&ds, "%s by signal %d",
WIFSIGNALED(status) ? "killed" : "stopped", signr);
if (name) {
ds_put_format(&ds, " (%s)", name);
}
} else {
ds_put_format(&ds, "terminated abnormally (%x)", status);
}
if (WCOREDUMP(status)) {
ds_put_cstr(&ds, ", core dumped");
}
return ds_cstr(&ds);
}
/* Given 'status', which is a process status in the form reported by waitpid(2)
* and returned by process_status(), returns a string describing how the
* process terminated. The caller is responsible for freeing the string when
* it is no longer needed. */
char *
process_status_msg(int status)
{
struct ds ds = DS_EMPTY_INITIALIZER;
#ifndef _WIN32
if (WIFEXITED(status)) {
ds_put_format(&ds, "exit status %d", WEXITSTATUS(status));
} else if (WIFSIGNALED(status)) {
char namebuf[SIGNAL_NAME_BUFSIZE];
ds_put_format(&ds, "killed (%s)",
signal_name(WTERMSIG(status), namebuf, sizeof namebuf));
} else if (WIFSTOPPED(status)) {
char namebuf[SIGNAL_NAME_BUFSIZE];
ds_put_format(&ds, "stopped (%s)",
signal_name(WSTOPSIG(status), namebuf, sizeof namebuf));
} else {
ds_put_format(&ds, "terminated abnormally (%x)", status);
}
if (WCOREDUMP(status)) {
ds_put_cstr(&ds, ", core dumped");
}
#else
ds_put_cstr(&ds, "function not supported.");
#endif
return ds_cstr(&ds);
}
char *
flow_to_string(const struct flow *flow)
{
struct ds ds = DS_EMPTY_INITIALIZER;
flow_format(&ds, flow);
return ds_cstr(&ds);
}
struct flow_table *
flow_table_create(struct datapath *dp, uint8_t table_id) {
struct flow_table *table;
struct ds string = DS_EMPTY_INITIALIZER;
ds_put_format(&string, "table_%u", table_id);
table = xmalloc(sizeof(struct flow_table));
table->dp = dp;
table->stats = xmalloc(sizeof(struct ofl_table_stats));
table->stats->table_id = table_id;
table->stats->name = ds_cstr(&string);
table->stats->match = DP_SUPPORTED_MATCH_FIELDS;
table->stats->instructions = DP_SUPPORTED_INSTRUCTIONS;
table->stats->write_actions = DP_SUPPORTED_ACTIONS;
table->stats->apply_actions = DP_SUPPORTED_ACTIONS;
table->stats->config = OFPTC_TABLE_MISS_CONTROLLER;
table->stats->max_entries = FLOW_TABLE_MAX_ENTRIES;
table->stats->active_count = 0;
table->stats->lookup_count = 0;
table->stats->matched_count = 0;
list_init(&table->match_entries);
list_init(&table->hard_entries);
list_init(&table->idle_entries);
return table;
}
static void
test_pcap(struct ovs_cmdl_context *ctx)
{
size_t total_count, batch_size_;
struct pcap_file *pcap;
int err = 0;
pcap = ovs_pcap_open(ctx->argv[1], "rb");
if (!pcap) {
return;
}
batch_size_ = 1;
if (ctx->argc > 2) {
batch_size_ = strtoul(ctx->argv[2], NULL, 0);
if (batch_size_ == 0 || batch_size_ > NETDEV_MAX_BURST) {
ovs_fatal(0,
"batch_size must be between 1 and NETDEV_MAX_BURST(%u)",
NETDEV_MAX_BURST);
}
}
fatal_signal_init();
ct = conntrack_init();
total_count = 0;
for (;;) {
struct dp_packet *packet;
struct dp_packet_batch pkt_batch_;
struct dp_packet_batch *batch = &pkt_batch_;
dp_packet_batch_init(batch);
for (int i = 0; i < batch_size_; i++) {
err = ovs_pcap_read(pcap, &packet, NULL);
if (err) {
break;
}
dp_packet_batch_add(batch, packet);
}
if (dp_packet_batch_is_empty(batch)) {
break;
}
pcap_batch_execute_conntrack(ct, batch);
DP_PACKET_BATCH_FOR_EACH (i, packet, batch) {
struct ds ds = DS_EMPTY_INITIALIZER;
total_count++;
format_flags(&ds, ct_state_to_string, packet->md.ct_state, '|');
printf("%"PRIuSIZE": %s\n", total_count, ds_cstr(&ds));
ds_destroy(&ds);
}
dp_packet_delete_batch(batch, true);
}
conntrack_destroy(ct);
ovs_pcap_close(pcap);
}
static void
jsonrpc_log_msg(const struct jsonrpc *rpc, const char *title,
const struct jsonrpc_msg *msg)
{
if (VLOG_IS_DBG_ENABLED()) {
struct ds s = DS_EMPTY_INITIALIZER;
if (msg->method) {
ds_put_format(&s, ", method=\"%s\"", msg->method);
}
if (msg->params) {
ds_put_cstr(&s, ", params=");
json_to_ds(msg->params, 0, &s);
}
if (msg->result) {
ds_put_cstr(&s, ", result=");
json_to_ds(msg->result, 0, &s);
}
if (msg->error) {
ds_put_cstr(&s, ", error=");
json_to_ds(msg->error, 0, &s);
}
if (msg->id) {
ds_put_cstr(&s, ", id=");
json_to_ds(msg->id, 0, &s);
}
VLOG_DBG("%s: %s %s%s", rpc->name, title,
jsonrpc_msg_type_to_string(msg->type), ds_cstr(&s));
ds_destroy(&s);
}
}
static int
parse_actions(const char *in)
{
struct ofpbuf odp_actions;
struct ds out;
int error;
/* Convert string to OVS DP actions. */
ofpbuf_init(&odp_actions, 0);
error = odp_actions_from_string(in, NULL, &odp_actions);
if (error) {
printf("odp_actions_from_string: error\n");
goto next;
}
/* Convert odp_actions back to string. */
ds_init(&out);
format_odp_actions(&out, odp_actions.data, odp_actions.size, NULL);
puts(ds_cstr(&out));
ds_destroy(&out);
next:
ofpbuf_uninit(&odp_actions);
return 0;
}
void
handle_acl_log(const struct flow *headers, struct ofpbuf *userdata)
{
if (!VLOG_IS_INFO_ENABLED()) {
return;
}
struct log_pin_header *lph = ofpbuf_try_pull(userdata, sizeof *lph);
if (!lph) {
VLOG_WARN("log data missing");
return;
}
size_t name_len = userdata->size;
char *name = name_len ? xmemdup0(userdata->data, name_len) : NULL;
struct ds ds = DS_EMPTY_INITIALIZER;
ds_put_cstr(&ds, "name=");
json_string_escape(name_len ? name : "<unnamed>", &ds);
ds_put_format(&ds, ", verdict=%s, severity=%s: ",
log_verdict_to_string(lph->verdict),
log_severity_to_string(lph->severity));
flow_format(&ds, headers, NULL);
VLOG_INFO("%s", ds_cstr(&ds));
ds_destroy(&ds);
free(name);
}
/* Generate a syntax fragment for NV and append it to STR */
static void
new_value_append_syntax (GString *str, const struct new_value *nv)
{
switch (nv->type)
{
case NV_NUMERIC:
g_string_append_printf (str, "%g", nv->v.v);
break;
case NV_STRING:
{
struct string ds = DS_EMPTY_INITIALIZER;
syntax_gen_string (&ds, ss_cstr (nv->v.s));
g_string_append (str, ds_cstr (&ds));
ds_destroy (&ds);
}
break;
case NV_COPY:
g_string_append (str, "COPY");
break;
case NV_SYSMIS:
g_string_append (str, "SYSMIS");
break;
default:
/* Shouldn't ever happen */
g_warning ("Invalid type in new recode value");
g_string_append (str, "???");
break;
}
}
char *
ovsdb_type_to_english(const struct ovsdb_type *type)
{
const char *key = ovsdb_atomic_type_to_string(type->key.type);
const char *value = ovsdb_atomic_type_to_string(type->value.type);
if (ovsdb_type_is_scalar(type)) {
return xstrdup(key);
} else {
struct ds s = DS_EMPTY_INITIALIZER;
ds_put_cstr(&s, ovsdb_type_is_set(type) ? "set" : "map");
if (type->n_max == UINT_MAX) {
if (type->n_min) {
ds_put_format(&s, " of %u or more", type->n_min);
} else {
ds_put_cstr(&s, " of");
}
} else if (type->n_min) {
ds_put_format(&s, " of %u to %u", type->n_min, type->n_max);
} else {
ds_put_format(&s, " of up to %u", type->n_max);
}
if (ovsdb_type_is_set(type)) {
ds_put_format(&s, " %ss", key);
} else {
ds_put_format(&s, " (%s, %s) pairs", key, value);
}
return ds_cstr(&s);
}
}
void
parse_ofp_flow_mod_file(const char *file_name, uint16_t command,
struct ofputil_flow_mod **fms, size_t *n_fms)
{
size_t allocated_fms;
FILE *stream;
struct ds s;
stream = !strcmp(file_name, "-") ? stdin : fopen(file_name, "r");
if (stream == NULL) {
ovs_fatal(errno, "%s: open", file_name);
}
allocated_fms = *n_fms;
ds_init(&s);
while (!ds_get_preprocessed_line(&s, stream)) {
if (*n_fms >= allocated_fms) {
*fms = x2nrealloc(*fms, &allocated_fms, sizeof **fms);
}
parse_ofp_flow_mod_str(&(*fms)[*n_fms], ds_cstr(&s), command, false);
*n_fms += 1;
}
ds_destroy(&s);
if (stream != stdin) {
fclose(stream);
}
}
/** Returns the current value of the interface header field.
*
* \relates adbus_MsgFactory
*
* \return NULL if the field is not set
*/
const char* adbus_msg_interface(const adbus_MsgFactory* m, size_t* len)
{
if (len)
*len = ds_size(&m->interface);
if (ds_size(&m->interface) > 0)
return ds_cstr(&m->interface);
else
return NULL;
}
static void
flush_help_string(struct ds *ds)
{
if (ds->length > 2 ) {
ds->length -= 2;
printf ("%s\n", ds_cstr(ds));
ds_clear(ds);
}
}
/** Returns the current value of the destination header field.
*
* \relates adbus_MsgFactory
*
* \return NULL if the field is not set
*/
const char* adbus_msg_destination(const adbus_MsgFactory* m, size_t* len)
{
if (len)
*len = ds_size(&m->destination);
if (ds_size(&m->destination) > 0)
return ds_cstr(&m->destination);
else
return NULL;
}
/** Returns the current value of the error name header field.
*
* \relates adbus_MsgFactory
*
* \return NULL if the field is not set
*/
const char* adbus_msg_error(const adbus_MsgFactory* m, size_t* len)
{
if (len)
*len = ds_size(&m->error);
if (ds_size(&m->error) > 0)
return ds_cstr(&m->error);
else
return NULL;
}
static void
output_frequency_table (const struct two_sample_test *t2s,
const struct sign_test_params *param,
const struct dictionary *dict)
{
int i;
struct tab_table *table = tab_create (3, 1 + 4 * t2s->n_pairs);
const struct variable *wv = dict_get_weight (dict);
const struct fmt_spec *wfmt = wv ? var_get_print_format (wv) : & F_8_0;
tab_set_format (table, RC_WEIGHT, wfmt);
tab_title (table, _("Frequencies"));
tab_headers (table, 2, 0, 1, 0);
/* Vertical lines inside the box */
tab_box (table, 0, 0, -1, TAL_1,
1, 0, tab_nc (table) - 1, tab_nr (table) - 1 );
/* Box around entire table */
tab_box (table, TAL_2, TAL_2, -1, -1,
0, 0, tab_nc (table) - 1, tab_nr (table) - 1 );
tab_text (table, 2, 0, TAB_CENTER, _("N"));
for (i = 0 ; i < t2s->n_pairs; ++i)
{
variable_pair *vp = &t2s->pairs[i];
struct string pair_name;
ds_init_cstr (&pair_name, var_to_string ((*vp)[0]));
ds_put_cstr (&pair_name, " - ");
ds_put_cstr (&pair_name, var_to_string ((*vp)[1]));
tab_text (table, 0, 1 + i * 4, TAB_LEFT, ds_cstr (&pair_name));
ds_destroy (&pair_name);
tab_hline (table, TAL_1, 0, tab_nc (table) - 1, 1 + i * 4);
tab_text (table, 1, 1 + i * 4, TAB_LEFT, _("Negative Differences"));
tab_text (table, 1, 2 + i * 4, TAB_LEFT, _("Positive Differences"));
tab_text (table, 1, 3 + i * 4, TAB_LEFT, _("Ties"));
tab_text (table, 1, 4 + i * 4, TAB_LEFT, _("Total"));
tab_double (table, 2, 1 + i * 4, TAB_RIGHT, param[i].neg, NULL, RC_WEIGHT);
tab_double (table, 2, 2 + i * 4, TAB_RIGHT, param[i].pos, NULL, RC_WEIGHT);
tab_double (table, 2, 3 + i * 4, TAB_RIGHT, param[i].ties, NULL, RC_WEIGHT);
tab_double (table, 2, 4 + i * 4, TAB_RIGHT,
param[i].ties + param[i].neg + param[i].pos, NULL, RC_WEIGHT);
}
tab_submit (table);
}
static char *
generate_syntax (const struct comment_dialog *cd)
{
gint i;
GString *str;
gchar *text;
GtkWidget *tv = get_widget_assert (cd->xml, "comments-textview1");
GtkWidget *check = get_widget_assert (cd->xml, "comments-checkbutton1");
GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (tv));
str = g_string_new ("\n* Data File Comments.\n\n");
if (dict_get_documents (cd->dict->dict) != NULL)
g_string_append (str, "DROP DOCUMENTS.\n");
g_string_append (str, "ADD DOCUMENT\n");
for (i = 0 ; i < gtk_text_buffer_get_line_count (buffer) ; ++i )
{
struct string tmp;
GtkTextIter start;
char *line;
gtk_text_buffer_get_iter_at_line (buffer, &start, i);
if (gtk_text_iter_ends_line (&start))
line = g_strdup ("");
else
{
GtkTextIter end = start;
gtk_text_iter_forward_to_line_end (&end);
line = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
}
ds_init_empty (&tmp);
syntax_gen_string (&tmp, ss_cstr (line));
g_free (line);
g_string_append_printf (str, " %s\n", ds_cstr (&tmp));
ds_destroy (&tmp);
}
g_string_append (str, " .\n");
if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check)))
g_string_append (str, "DISPLAY DOCUMENTS.\n");
text = str->str;
g_string_free (str, FALSE);
return text;
}
static void
output_statistics_table (const struct two_sample_test *t2s,
const struct sign_test_params *param)
{
int i;
struct tab_table *table = tab_create (1 + t2s->n_pairs, 4);
tab_title (table, _("Test Statistics"));
tab_headers (table, 0, 1, 0, 1);
tab_hline (table, TAL_2, 0, tab_nc (table) - 1, 1);
tab_vline (table, TAL_2, 1, 0, tab_nr (table) - 1);
/* Vertical lines inside the box */
tab_box (table, -1, -1, -1, TAL_1,
0, 0,
tab_nc (table) - 1, tab_nr (table) - 1);
/* Box around entire table */
tab_box (table, TAL_2, TAL_2, -1, -1,
0, 0, tab_nc (table) - 1,
tab_nr (table) - 1);
tab_text (table, 0, 1, TAT_TITLE | TAB_LEFT,
_("Exact Sig. (2-tailed)"));
tab_text (table, 0, 2, TAT_TITLE | TAB_LEFT,
_("Exact Sig. (1-tailed)"));
tab_text (table, 0, 3, TAT_TITLE | TAB_LEFT,
_("Point Probability"));
for (i = 0 ; i < t2s->n_pairs; ++i)
{
variable_pair *vp = &t2s->pairs[i];
struct string pair_name;
ds_init_cstr (&pair_name, var_to_string ((*vp)[0]));
ds_put_cstr (&pair_name, " - ");
ds_put_cstr (&pair_name, var_to_string ((*vp)[1]));
tab_text (table, 1 + i, 0, TAB_LEFT, ds_cstr (&pair_name));
ds_destroy (&pair_name);
tab_double (table, 1 + i, 1, TAB_RIGHT,
param[i].one_tailed_sig * 2, NULL, RC_PVALUE);
tab_double (table, 1 + i, 2, TAB_RIGHT, param[i].one_tailed_sig, NULL, RC_PVALUE);
tab_double (table, 1 + i, 3, TAB_RIGHT, param[i].point_prob, NULL, RC_PVALUE);
}
tab_submit (table);
}
static void
ipf_print_reass_packet(const char *es, const void *pkt)
{
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(10, 10);
if (!VLOG_DROP_WARN(&rl)) {
struct ds ds = DS_EMPTY_INITIALIZER;
ds_put_hex_dump(&ds, pkt, 128, 0, false);
VLOG_WARN("%s\n%s", es, ds_cstr(&ds));
ds_destroy(&ds);
}
}
/* Returns a string that describes some of 'b''s metadata plus a hex dump of up
* to 'maxbytes' from the start of the buffer. */
char *
ofpbuf_to_string(const struct ofpbuf *b, size_t maxbytes)
{
struct ds s;
ds_init(&s);
ds_put_format(&s, "size=%"PRIu32", allocated=%"PRIu32", head=%"PRIuSIZE", tail=%"PRIuSIZE"\n",
b->size, b->allocated,
ofpbuf_headroom(b), ofpbuf_tailroom(b));
ds_put_hex_dump(&s, b->data, MIN(b->size, maxbytes), 0, false);
return ds_cstr(&s);
}
/* Returns a string that describes some of 'b''s metadata plus a hex dump of up
* to 'maxbytes' from the start of the buffer. */
char *
dp_packet_to_string(const struct dp_packet *b, size_t maxbytes)
{
struct ds s;
ds_init(&s);
ds_put_format(&s, "size=%"PRIu32", allocated=%"PRIu32", head=%"PRIuSIZE", tail=%"PRIuSIZE"\n",
dp_packet_size(b), b->allocated,
dp_packet_headroom(b), dp_packet_tailroom(b));
ds_put_hex_dump(&s, dp_packet_data(b), MIN(dp_packet_size(b), maxbytes), 0, false);
return ds_cstr(&s);
}
static void AppendObjectPath(adbus_MsgFactory* m, adbus_BufArray* a, uint8_t code, d_String* field)
{
if (ds_size(field) > 0) {
adbus_BufVariant v;
adbus_buf_arrayentry(m->buf, a);
adbus_buf_beginstruct(m->buf);
adbus_buf_u8(m->buf, code);
adbus_buf_beginvariant(m->buf, &v, "o", 1);
adbus_buf_objectpath(m->buf, ds_cstr(field), ds_size(field));
adbus_buf_endvariant(m->buf, &v);
adbus_buf_endstruct(m->buf);
}
}
/* Create a table which can be populated with the encodings for
the covariance matrix COV */
struct tab_table *
covariance_dump_enc_header (const struct covariance *cov, int length)
{
struct tab_table *t = tab_create (cov->dim, length);
int n;
int i;
tab_title (t, "Covariance Encoding");
tab_box (t,
TAL_2, TAL_2, 0, 0,
0, 0, tab_nc (t) - 1, tab_nr (t) - 1);
tab_hline (t, TAL_2, 0, tab_nc (t) - 1, 1);
for (i = 0 ; i < cov->n_vars; ++i)
{
tab_text (t, i, 0, TAT_TITLE, var_get_name (cov->vars[i]));
tab_vline (t, TAL_1, i + 1, 0, tab_nr (t) - 1);
}
n = 0;
while (i < cov->dim)
{
struct string str;
int idx = i - cov->n_vars;
const struct interaction *iact =
categoricals_get_interaction_by_subscript (cov->categoricals, idx);
int df;
ds_init_empty (&str);
interaction_to_string (iact, &str);
df = categoricals_df (cov->categoricals, n);
tab_joint_text (t,
i, 0,
i + df - 1, 0,
TAT_TITLE, ds_cstr (&str));
if (i + df < tab_nr (t) - 1)
tab_vline (t, TAL_1, i + df, 0, tab_nr (t) - 1);
i += df;
n++;
ds_destroy (&str);
}
return t;
}
void
ofp_version_usage(void)
{
struct ds msg = DS_EMPTY_INITIALIZER;
ofputil_format_version_bitmap_names(&msg, OFPUTIL_DEFAULT_VERSIONS);
printf(
"\nOpenFlow version options:\n"
" -V, --version display version information\n"
" -O, --protocols set allowed OpenFlow versions\n"
" (default: %s)\n",
ds_cstr(&msg));
ds_destroy(&msg);
}
