From b7bc3d195a03208085ad296afe18a38621eb64df Mon Sep 17 00:00:00 2001 From: Katerina Kubecova Date: Fri, 22 Dec 2023 16:42:14 +0100 Subject: [PATCH] print_cbor: ospf show topology somehow works --- client/client.c | 87 +++++- client/print_cbor.c | 596 ++++++++++++++++++++++++++++++++++++- nest/cbor_parse.c | 26 +- nest/cli.c | 9 +- proto/ospf/ospf_for_cbor.c | 2 +- yang/birdc.py | 7 +- 6 files changed, 705 insertions(+), 22 deletions(-) diff --git a/client/client.c b/client/client.c index 9f85bb5d..2149d1a0 100644 --- a/client/client.c +++ b/client/client.c @@ -123,6 +123,8 @@ parse_args(int argc, char **argv) /*** Input ***/ static void server_send(char *cmd); +static void +server_send_byte(byte *cmd, int l); static int handle_internal_command(char *cmd) @@ -152,70 +154,105 @@ uint compare_string(byte *str1, uint length, const char *str2) { return 1; } +void write_args_cbor(char *cmd_buffer, struct cbor_writer *w) +{ + size_t l = strlen(cmd_buffer); + size_t pt = 0; + while (cmd_buffer[pt] == ' ') + pt++; + if (pt+1 >= l) + { + return; + } + cbor_add_string(w, "args"); + cbor_open_list(w); + while (l>pt) + { + size_t next_space = 0; + while (next_space + pt < l && cmd_buffer[next_space + pt] != ' ') + next_space++; + cbor_open_block_with_length(w, 1); + cbor_add_string(w, "arg"); + cbor_nonterminated_string(w, &cmd_buffer[pt], next_space); + pt += next_space; + while (cmd_buffer[pt] == ' ') + pt++; + } + cbor_close_block_or_list(w); +} void make_cmd_cbor(char *cmd_buffer) { - printf("input got line yi\n%s\n", cmd_buffer); size_t l = strlen(cmd_buffer); char cbor_buf[l*10]; struct linpool *lp = lp_new(&root_pool); struct cbor_writer *w = cbor_init(cbor_buf, l*10, lp); cbor_open_block_with_length(w, 1); - printf("main block opened"); cbor_add_string(w, "command:do"); - cbor_open_block(w); char *show = "show "; int buf_pt = 0; if (compare_string(cmd_buffer, l, show)) { - printf("show recognised\n"); + cbor_open_block(w); buf_pt += strlen(show); l -= strlen(show); if (compare_string(&cmd_buffer[buf_pt], l, "memory")) { - printf("show memory...\n"); cbor_string_int(w, "command", SHOW_MEMORY); cbor_close_block_or_list(w); + server_send_byte(cbor_buf, w->pt); lp_flush(lp); - server_send(cbor_buf); return; } else if (compare_string(&cmd_buffer[buf_pt], l, "status")) { cbor_string_int(w, "command", SHOW_STATUS); cbor_close_block_or_list(w); + cbor_write_to_file(w, "status_command.cbor"); + server_send_byte(cbor_buf, w->pt); lp_flush(lp); - server_send(cbor_buf); return; } else if (compare_string(&cmd_buffer[buf_pt], l, "symbols")) { cbor_string_int(w, "command", SHOW_SYMBOLS); + write_args_cbor(&cmd_buffer[buf_pt + strlen("symbols ")], w); cbor_close_block_or_list(w); + server_send_byte(cbor_buf, w->pt); lp_flush(lp); - server_send(cbor_buf); + return; } else if (compare_string(&cmd_buffer[buf_pt], l, "ospf")) { cbor_string_int(w, "command", SHOW_OSPF); + write_args_cbor(&cmd_buffer[buf_pt + strlen("ospf")], w); + cbor_close_block_or_list(w); + server_send_byte(cbor_buf, w->pt); + lp_flush(lp); + return; } else { - printf("this command is not implemented yet"); + printf("this command is not implemented yet\n"); } } + else if (compare_string(cmd_buffer, l, "down")) + { + cbor_add_string(w, "down"); + server_send_byte(cbor_buf, w->pt); + return; + } lp_flush(lp); - printf("this command is not implemented yet"); + printf("this command is not implemented yet\n"); } static void submit_server_command(char *cmd) { - printf("command %s\n", cmd); if (cbor_mode) { make_cmd_cbor(cmd); @@ -418,7 +455,6 @@ server_got_binary(int c) static void server_read(void) { - printf("server read\n"); int c; byte *start, *p; @@ -555,6 +591,33 @@ server_send(char *cmd) } } +static void +server_send_byte(byte *cmd, int l) +{ + byte *z = alloca(l); + + memcpy(z, cmd, l); + while (l) + { + int cnt = write(server_fd, z, l); + + if (cnt < 0) + { + if (errno == EAGAIN) + wait_for_write(server_fd); + else if (errno == EINTR) + continue; + else + DIE("Server write error"); + } + else + { + l -= cnt; + z += cnt; + } + } +} + int main(int argc, char **argv) { diff --git a/client/print_cbor.c b/client/print_cbor.c index b07ef791..671fa00d 100644 --- a/client/print_cbor.c +++ b/client/print_cbor.c @@ -1,4 +1,4 @@ - +#include #include "nest/cbor_parse.c" void print_with_size(byte *string, int len) @@ -12,6 +12,462 @@ void print_with_size(byte *string, int len) } } +void print_with_size_(byte *string, int len) +{ + for (int i = 0; i < len; i++) + { + putc(string[i], stdout); + } +} + +void print_ip_addr(struct buff_reader *buf_read) +{ + struct value val = get_value(buf_read); // tag + val = get_value(buf_read); // bytestring + for (int i = 0; i < val.val-1; i++) + { + printf("%i.", buf_read->buff[buf_read->pt + i]); + } + printf("%i", buf_read->buff[buf_read->pt + val.val]); + buf_read->pt+=val.val; +} + +void print_ip_prefix(struct buff_reader *buf_read) +{ + struct value val = get_value(buf_read); // tag + val = get_value(buf_read); // block + val = get_value(buf_read); + long prefix = val.val; + val = get_value(buf_read); // bytestring + for (int i = 0; i < val.val-1; i++) + { + printf("%i.", buf_read->buff[buf_read->pt + i]); + } + printf("%i/%li", buf_read->buff[buf_read->pt + val.val], prefix); + buf_read->pt+=val.val; +} + +void print_distance(struct buff_reader *buf_read) +{ + struct value val = get_value(buf_read); + ASSERT(compare_buff_str(buf_read, val.val, "distance")); + buf_read->pt+=val.val; + val = get_value(buf_read); + if (val.major == UINT) + { + printf("\t\tdistance %li\n", val.val); + return; + } + else if (val.major == TEXT) + { + printf("\t\tdistance "); + print_with_size_(&buf_read->buff[buf_read->pt], val.val); + buf_read->pt+=val.val; + printf("\n"); + return; + } + bug("print distance on incorrect type %i\n", val.major); +} + +void discard_key(struct buff_reader *buf_read) +{ + struct value val = get_value(buf_read); + if(!(val.major == TEXT)) + { + bug("key is not text but %i", val.major); + } + buf_read->pt+=val.val; +} + +void print_time(int64_t time) +{ + struct tm tm = *localtime(&time); + printf("%d-%02d-%02d %02d:%02d:%02d", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec); + +} + + +void print_lsa_router(struct buff_reader *buf_read) +{ + struct value val = get_value(buf_read); + ASSERT(val.major == BLOCK); + discard_key(buf_read); + printf("\trouter "); + print_ip_addr(buf_read); + printf("\n"); + print_distance(buf_read); + discard_key(buf_read); // vlink + val = get_value(buf_read); + ASSERT(val.major == ARRAY); + val = get_value(buf_read); + while (!val_is_break(val)) + { + discard_key(buf_read); + printf("\t\tvlink "); + print_ip_addr(buf_read); + discard_key(buf_read); + val = get_value(buf_read); + printf(" metric %li\n", val.val); + val = get_value(buf_read); + } + + discard_key(buf_read); // router metric + val = get_value(buf_read); + ASSERT(val.major == ARRAY); + val = get_value(buf_read); + while (!val_is_break(val)) + { + discard_key(buf_read); + printf("\t\trouter "); + print_ip_addr(buf_read); + val = get_value(buf_read); + buf_read->pt+=val.val; + val = get_value(buf_read); + printf(" metric %li\n", val.val); + val = get_value(buf_read); + } + + discard_key(buf_read); // network + val = get_value(buf_read); + ASSERT(val.major == ARRAY); + val = get_value(buf_read); + while (!val_is_break(val)) + { + ASSERT(val.major == BLOCK); + int block_len = val.val; + discard_key(buf_read); // dummy id + val = get_value(buf_read); //id num + discard_key(buf_read); // network + int bracket = !(block_len == 4 && buf_read->buff[buf_read->pt + 8] == 'l'); + printf("\t\tnetwork "); + if (bracket) + printf("["); + print_ip_addr(buf_read); + val = get_value(buf_read); + if (compare_buff_str(buf_read, val.val, "nif")) + { + printf("-"); + buf_read->pt+=val.val; + val = get_value(buf_read); + printf("%li", val.val); + } + else if (compare_buff_str(buf_read, val.val, "len")) + { + printf("/"); + buf_read->pt+=val.val; + val = get_value(buf_read); + printf("%li", val.val); + } + if (bracket) + printf("]"); + discard_key(buf_read); + val = get_value(buf_read); + printf(" metric %li\n", val.val); + val = get_value(buf_read); + } + val = get_value(buf_read); + if (!val_is_break(val)) + { + val = get_value(buf_read); // open list + while (!val_is_break(val)) + { + buf_read->pt+=val.val; // stubnet + val = get_value(buf_read); // open block + discard_key(buf_read); // stubnet + printf("\t\tstubnet "); + val = get_value(buf_read); + print_ip_addr(buf_read); + discard_key(buf_read); // len + val = get_value(buf_read); + printf("/%li", val.val); + discard_key(buf_read); // metric + val = get_value(buf_read); + printf(" metric %li\n", val.val); + } + val = get_value(buf_read); + } +} + + +void print_lsa_network(struct buff_reader *buf_read) +{ + struct value val = get_value(buf_read); + ASSERT(val.major == BLOCK); + val = get_value(buf_read); + ASSERT(val.major == TEXT); + if (compare_buff_str(buf_read, val.val, "ospf2")) + { + buf_read->pt+=val.val; + val = get_value(buf_read); + ASSERT(val.major == BLOCK); + discard_key(buf_read); // network + printf("\tnetwork "); + print_ip_addr(buf_read); + printf("/"); + discard_key(buf_read); // optx + val = get_value(buf_read); + printf("%li\n", val.val); + + discard_key(buf_read); // dr + printf("\t\tdr "); + print_ip_addr(buf_read); + printf("\n"); + } + else if (compare_buff_str(buf_read, val.val, "ospf")) + { + buf_read->pt+=val.val; + val = get_value(buf_read); + ASSERT(val.major == BLOCK); + discard_key(buf_read); // network + printf("\tnetwork "); + print_ip_addr(buf_read); + discard_key(buf_read); // lsa id + val = get_value(buf_read); + printf("-%li\n", val.val); + } + print_distance(buf_read); + discard_key(buf_read); // routers + val = get_value(buf_read); + ASSERT(val.major == ARRAY); + val = get_value(buf_read); + while (!val_is_break(val)) + { + discard_key(buf_read); + printf("\t\trouter "); + print_ip_addr(buf_read); + printf("\n"); + val = get_value(buf_read); + } +} + + +void print_lsa_sum_net(struct buff_reader *buf_read) +{ + struct value val = get_value(buf_read); + ASSERT(val.major == BLOCK); + discard_key(buf_read); + printf("\t\txnetwork "); + print_ip_prefix(buf_read); + discard_key(buf_read); + val = get_value(buf_read); + printf("metric %li\n", val.val); +} + + +void print_lsa_sum_rt(struct buff_reader *buf_read) +{ + struct value val = get_value(buf_read); + ASSERT(val.major == BLOCK); + discard_key(buf_read); + printf("\t\txrouter "); + print_ip_addr(buf_read); + discard_key(buf_read); + val = get_value(buf_read); + printf("metric %li\n", val.val); +} + + +void print_lsa_external(struct buff_reader *buf_read) +{ + struct value val = get_value(buf_read); + ASSERT(val.major == BLOCK); + val = get_value(buf_read); + int via = 0; + if (compare_buff_str(buf_read, val.val, "via")) + { + buf_read->pt+=val.val; + via = buf_read->pt; + val = get_value(buf_read); // tag + val = get_value(buf_read); // bytestring + buf_read->pt+=val.val; + val = get_value(buf_read); + } + long tag = -1; + if (compare_buff_str(buf_read, val.val, "tag")) + { + buf_read->pt+=val.val; + val = get_value(buf_read); + tag = val.val; + val = get_value(buf_read); + } + discard_key(buf_read); // lsa type + printf("\t\t"); + val = get_value(buf_read); + print_with_size_(&buf_read->buff[buf_read->pt], val.val); + printf(" "); + discard_key(buf_read); + print_ip_addr(buf_read); + discard_key(buf_read); + + printf(" metric"); + val = get_value(buf_read); + if (compare_buff_str(buf_read, val.val, "lsa_type_num")) + { + buf_read->pt+=val.val; + val = get_value(buf_read); + printf("%li", val.val); + val = get_value(buf_read); + } + buf_read->pt+=val.val; + val = get_value(buf_read); + printf(" %li", val.val); + if (via) + { + printf(" via "); + int pt = buf_read->pt; + buf_read->pt = via; + print_ip_addr(buf_read); + buf_read->pt = pt; + } + if (tag >- 1) + { + printf(" tag %08lx", tag); + } + val = get_value(buf_read); // end of block +} + + +void print_lsa_prefix(struct buff_reader *buf_read) +{ + struct value val = get_value(buf_read); + ASSERT(val.major == BLOCK); + val = get_value(buf_read); + if (val_is_break(val)) + return; + discard_key(buf_read); + val = get_value(buf_read); // open block or break + while (!val_is_break(val)) + { + val = get_value(buf_read); + if (compare_buff_str(buf_read, val.val, "stubnet")) + { + buf_read->pt+=val.val; + printf("\t\tstubnet "); + print_ip_prefix(buf_read); + discard_key(buf_read); + val = get_value(buf_read); + printf(" metric %li", val.val); + } + else + { + buf_read->pt+=val.val; + printf("\t\taddress "); + print_ip_prefix(buf_read); + } + printf("\n"); + val = get_value(buf_read); + val = get_value(buf_read); // open block or break + } + val = get_value(buf_read); + print_ip_addr(buf_read); +} + +void print_show_ospf(struct buff_reader *buf_read) +{ + struct value val = get_value(buf_read); + ASSERT(val.major == BLOCK); + val = get_value(buf_read); + printf("\n"); + if (compare_buff_str(buf_read, val.val, "error")) + { + buf_read->pt+=val.val; + val = get_value(buf_read); + printf("error: "); + print_with_size(&buf_read->buff[buf_read->pt], val.val); + printf("\n"); + return; + } + if (compare_buff_str(buf_read, val.val, "not_implemented")) + { + buf_read->pt+=val.val; + val = get_value(buf_read); + printf("not implemented: "); + print_with_size(&buf_read->buff[buf_read->pt], val.val); + printf("\n"); + return; + } + buf_read->pt+=val.val; + val = get_value(buf_read); // list + ASSERT(val.major == ARRAY); + int j = val.val; + for (int i = 0; i < j; i++) + { + val = get_value(buf_read); // open block + ASSERT(val.major == BLOCK); + discard_key(buf_read); // dummy id + val = get_value(buf_read); + ASSERT(val.major == UINT); + val = get_value(buf_read); + if (compare_buff_str(buf_read, val.val, "area")) + { + buf_read->pt+=val.val; + printf("area "); + print_ip_addr(buf_read); + printf("\n"); + val = get_value(buf_read); + } + if (compare_buff_str(buf_read, val.val, "lsa_router")) + { + buf_read->pt+=val.val; + print_lsa_router(buf_read); + } + else if (compare_buff_str(buf_read, val.val, "lsa_network")) + { + buf_read->pt+=val.val; + print_lsa_network(buf_read); + } + else if (compare_buff_str(buf_read, val.val, "lsa_sum_net")) + { + buf_read->pt+=val.val; + print_lsa_sum_net(buf_read); + } + else if (compare_buff_str(buf_read, val.val, "lsa_sum_rt")) + { + buf_read->pt+=val.val; + print_lsa_sum_rt(buf_read); + } + else if (compare_buff_str(buf_read, val.val, "lsa_prefix")) + { + buf_read->pt+=val.val; + print_lsa_prefix(buf_read); + } + else if (compare_buff_str(buf_read, val.val, "lsa_external")) + { + buf_read->pt+=val.val; + print_lsa_external(buf_read); + } + val = get_value(buf_read); + } + discard_key(buf_read); + val = get_value(buf_read); + while (!val_is_break(val)) + { + val = get_value(buf_read); + if (val_is_break(val)) + return; + if (compare_buff_str(buf_read, val.val, "other_ABSRs")) + { + buf_read->pt+=val.val; + printf("other ABSRs\n"); + val = get_value(buf_read); // null list + val = get_value(buf_read); + } + if (compare_buff_str(buf_read, val.val, "router")) + { + buf_read->pt+=val.val; + printf("router "); + print_ip_addr(buf_read); + val = get_value(buf_read); + } + buf_read->pt+=val.val; + print_lsa_external(buf_read); + val = get_value(buf_read); + val = get_value(buf_read); + } +} + + + void print_show_memory(struct buff_reader *buf_read) { printf("BIRD memory usage\n"); @@ -56,6 +512,120 @@ void print_show_memory(struct buff_reader *buf_read) } } +void print_show_status(struct buff_reader *buf_read) +{ + /* + print("BIRD", answer["show_status:message"]["version"]) + for key in answer["show_status:message"]["body"].keys(): + name = key.replace("_", " ") + if key == "router_id": + print(name, self.addr_to_str( answer["show_status:message"]["body"][key])) + elif key in "server_time last_reboot last_reconfiguration": + print(name, datetime.datetime.fromtimestamp(answer["show_status:message"]["body"][key])) + else: + print(name, answer["show_status:message"]["body"][key]) + print(answer["show_status:message"]["state"]) + */ + struct value val = get_value(buf_read); + ASSERT(val.major == BLOCK); + val = get_value(buf_read); + ASSERT(val.major == TEXT); + buf_read->pt+=val.val; + val = get_value(buf_read); + ASSERT(val.major == TEXT); + printf("BIRD "); + print_with_size(&buf_read->buff[buf_read->pt], val.val); + printf("\n"); + buf_read->pt+=val.val; + val = get_value(buf_read); + ASSERT(val.major == TEXT); // body + buf_read->pt+=val.val; + val = get_value(buf_read); + ASSERT(val.major == BLOCK); + val = get_value(buf_read); + ASSERT(val.major == TEXT); // router id + buf_read->pt+=val.val; + printf("router id: "); + print_ip_addr(buf_read); + printf("\n"); + + val = get_value(buf_read); + ASSERT(val.major == TEXT); // hostname + buf_read->pt+=val.val; + printf("hostname: "); + val = get_value(buf_read); + ASSERT(val.major == TEXT); + print_with_size(&buf_read->buff[buf_read->pt], val.val); + printf("\n"); + buf_read->pt+=val.val; + + for (int i =0; i<3; i++) + { + val = get_value(buf_read); + ASSERT(val.major == TEXT); // server time, last rebooot, last reconfiguration + print_with_size(&buf_read->buff[buf_read->pt], val.val); + buf_read->pt+=val.val; + printf(": "); + val = get_value(buf_read); + ASSERT(val.major == UINT); + print_time(val.val); + printf("\n"); + } + val = get_value(buf_read); + if (val.major != TEXT) + val = get_value(buf_read); + ASSERT(val.major == TEXT); // state + printf("state: "); + buf_read->pt+=val.val; + val = get_value(buf_read); + ASSERT(val.major == TEXT); + print_with_size(&buf_read->buff[buf_read->pt], val.val); + printf("\n"); + buf_read->pt+=val.val; +} + +void print_show_symbols(struct buff_reader *buf_read) +{ + struct value val = get_value(buf_read); + ASSERT(val.major == BLOCK); + discard_key(buf_read); + val = get_value(buf_read); + int one_item = 0; + if (val.val == 1) + one_item = 1; + if (val.val == 0) + return; + val = get_value(buf_read); + if (val_is_break(val)) + { + printf("no names found\n"); + return; + } + val = get_value(buf_read); + while (val.major == TEXT) + { + buf_read->pt+=val.val; //name + val = get_value(buf_read); + print_with_size_(&buf_read->buff[buf_read->pt], val.val); + for (int i = val.val; i < 15; i++) + { + printf(" "); + } + buf_read->pt+=val.val; + val = get_value(buf_read); //type + buf_read->pt+=val.val; + val = get_value(buf_read); + print_with_size_(&buf_read->buff[buf_read->pt], val.val); + printf("\n"); + buf_read->pt+=val.val; + if (one_item) + return; + val = get_value(buf_read); + if (val_is_break(val)) + return; + val = get_value(buf_read); + } +} void print_cbor_response(byte *cbor, int len) { @@ -64,15 +634,37 @@ void print_cbor_response(byte *cbor, int len) buf_read.size = len; buf_read.pt = 0; struct value val = get_value(&buf_read); - printf("%i %li\n", val.major, val.val); ASSERT(val.major == BLOCK); ASSERT(val.val <=1); val = get_value(&buf_read); ASSERT(val.major == TEXT); + printf("\n"); if (compare_buff_str(&buf_read, val.val, "show_memory:message")) { buf_read.pt += val.val; print_show_memory(&buf_read); } + else if (compare_buff_str(&buf_read, val.val, "show_status:message")) + { + buf_read.pt += val.val; + print_show_status(&buf_read); + } + else if (compare_buff_str(&buf_read, val.val, "show_symbols:message")) + { + buf_read.pt += val.val; + print_show_symbols(&buf_read); + } + else if (compare_buff_str(&buf_read, val.val, "show_ospf:message")) + { + buf_read.pt += val.val; + print_show_ospf(&buf_read); + } + printf("\nbird>"); + fflush(stdout); } + + + + + diff --git a/nest/cbor_parse.c b/nest/cbor_parse.c index 1ea13b64..d1717ec4 100644 --- a/nest/cbor_parse.c +++ b/nest/cbor_parse.c @@ -119,6 +119,7 @@ void skip_optional_args(struct buff_reader *rbuf_read, int items_in_block) { log("items in block %i", items_in_block); ASSERT(items_in_block == -1); // assert the block was not open to exact num of items, because it cant be just for command (we would returned) and we did not find more items. + ASSERT(val_is_break(val)); rbuf_read->pt--; // we read one byte from future, we need to shift pointer back. The val should be break, but we are not going to close the block, because it was not opened here. } } @@ -210,15 +211,18 @@ struct arg_list *parse_arguments(struct buff_reader *rbuf_read, int items_in_blo uint do_command(struct buff_reader *rbuf_read, struct buff_reader *tbuf_read, int items_in_block, struct linpool *lp) { + log("val from %i", rbuf_read->buff[rbuf_read->pt]); struct value val = get_value(rbuf_read); ASSERT(val.major == UINT); struct arg_list * args; + log("command %li, major %i", val.val, val.major); switch (val.val) { case SHOW_MEMORY: skip_optional_args(rbuf_read, items_in_block); return cmd_show_memory_cbor(tbuf_read->buff, tbuf_read->size, lp); case SHOW_STATUS: + log("show status"); skip_optional_args(rbuf_read, items_in_block); return cmd_show_status_cbor(tbuf_read->buff, tbuf_read->size, lp); case SHOW_SYMBOLS: @@ -228,17 +232,32 @@ do_command(struct buff_reader *rbuf_read, struct buff_reader *tbuf_read, int ite args = parse_arguments(rbuf_read, items_in_block, lp); log("args %i, pt %i", args, args->pt); return cmd_show_ospf_cbor(tbuf_read->buff, tbuf_read->size, args, lp); - return 0; default: + bug("command %li not found", val.val); return 0; } } +uint +detect_down(uint size, byte *rbuf) +{ + struct buff_reader rbuf_read; + rbuf_read.buff = rbuf; + rbuf_read.size = size; + rbuf_read.pt = 0; + struct value val = get_value(&rbuf_read); + ASSERT(val.major == BLOCK); + val = get_value(&rbuf_read); + ASSERT(compare_buff_str(&rbuf_read, val.val, "command:do")); + rbuf_read.pt+=val.val; + val = get_value(&rbuf_read); + return (val.major = TEXT && compare_buff_str(&rbuf_read, val.val, "down")); +} + uint parse_cbor(uint size, byte *rbuf, byte *tbuf, uint tbsize, struct linpool* lp) { - log("cbor parse, tb size %i tb %i", tbsize, tbuf); struct buff_reader rbuf_read; struct buff_reader tbuf_read; rbuf_read.buff = rbuf; @@ -254,7 +273,7 @@ parse_cbor(uint size, byte *rbuf, byte *tbuf, uint tbsize, struct linpool* lp) } struct value val = get_value(&rbuf_read); ASSERT(val.major == BLOCK); - ASSERT(val.val <=1); + ASSERT(val.val <=1); int wait_for_end_main_block = val.val == -1; if (val.val != 0) { @@ -281,6 +300,7 @@ parse_cbor(uint size, byte *rbuf, byte *tbuf, uint tbsize, struct linpool* lp) if (items_in_block == -1) { val = get_value(&rbuf_read); + log("val before fall %i %li", val.major, val.val); ASSERT(val.major == FLOAT && val.val == -1); } } diff --git a/nest/cli.c b/nest/cli.c index 5caeaafd..c829d3f2 100644 --- a/nest/cli.c +++ b/nest/cli.c @@ -73,6 +73,7 @@ pool *cli_pool; pool *yi_pool; +struct linpool *yi_lnpool; static byte * cli_alloc_out(cli *c, int size) @@ -398,7 +399,12 @@ cli_kick(cli *c) uint yi_process(uint size, byte *rbuf, byte *tbuf, uint tbsize) { log("capacity %i buffer %i", tbsize, tbuf); - return parse_cbor(size, rbuf, tbuf, tbsize, lp_new(yi_pool)); + if (detect_down(size, rbuf)) + { + order_shutdown(0); + return 0; + } + return parse_cbor(size, rbuf, tbuf, tbsize, yi_lnpool); } static list cli_log_hooks; @@ -506,6 +512,7 @@ void yi_init(void) { yi_pool = rp_new(&root_pool, "YI"); + yi_lnpool = lp_new(yi_pool); init_list(&yi_log_hooks); /*we may be do not need this*/ yi_log_inited = 1; } diff --git a/proto/ospf/ospf_for_cbor.c b/proto/ospf/ospf_for_cbor.c index 35428548..4a4148ec 100644 --- a/proto/ospf/ospf_for_cbor.c +++ b/proto/ospf/ospf_for_cbor.c @@ -275,7 +275,7 @@ show_lsa_prefix_cbor(struct cbor_writer *w, struct top_hash_entry *he, struct to cbor_string_int(w, "metric", metric); } else{ - cbor_add_string(w, "stubnet"); + cbor_add_string(w, "address"); cbor_add_net(w, &net); } cbor_close_block_or_list(w); diff --git a/yang/birdc.py b/yang/birdc.py index 46e7cda2..198c9722 100644 --- a/yang/birdc.py +++ b/yang/birdc.py @@ -123,14 +123,16 @@ class Ospf(Command): for prefix in area['prefixes']: if 'metric' in prefix.keys(): print(f"\t\tstubnet {self.prefix_to_str(prefix['stubnet'])} metric {prefix['metric']}") + else: + print(f"\t\taddress {self.prefix_to_str(prefix['address'])}") def print_answer(self, answer): print() if ("error" in answer["show_ospf:message"].keys()): print("error: ", answer["show_ospf:message"]["error"]) return - if ("not implemented" in answer["show_ospf:message"].keys()): - print("not implemented: ", answer["show_ospf:message"]["not implemented"]) + if ("not_implemented" in answer["show_ospf:message"].keys()): + print("not implemented: ", answer["show_ospf:message"]["not_implemented"]) return for area in answer["show_ospf:message"]["areas"]: if 'area' in area.keys(): @@ -152,7 +154,6 @@ class Ospf(Command): for asbr in area['asbrs']: if('other_ABSRs' in asbr.keys()): print("other ASBRs") - print("other ASBRs") print(f"\trouter {self.addr_to_str(asbr['router'])}") command_dictionary = {"status":0, "memory":1, "symbols":2, "ospf":3}