int main(int argc, char *argv[]) { struct rooted_tree *tree; struct parameters params; static struct rooted_tree * (*process_tree)(struct rooted_tree *, set_t *); params = get_params(argc, argv); switch (params.mode) { case PRUNE_DIRECT: process_tree = process_tree_direct; break; case PRUNE_REVERSE: process_tree = process_tree_reverse; break; default: assert (0); } while (NULL != (tree = parse_tree())) { tree = process_tree(tree, params.prune_labels); dump_newick(tree->root); destroy_all_rnodes(NULL); destroy_tree(tree); } destroy_set(params.prune_labels); return 0; }
/** * Deallocate Kruskal structures * @param al pointer to adjacency list graph representation * @param fnode_array forest nodes array * @param edge_membership designates whether an edge is part of the MSF */ void kruskal_destroy(adjlist_t *al, forest_node_t **fnode_array, unsigned int *edge_membership) { unsigned int v; assert(al); for ( v = 0; v < al->nvertices; v++ ) destroy_set(fnode_array[v]); free(fnode_array); free(edge_membership); }
/** * Invoked to cleanup a set once we * have hit 0 remaining references. */ static void delete_set(hlld_set_wrapper *set) { // Delete or Close the set if (set->should_delete) hset_delete(set->set); else hset_close(set->set); // Cleanup the set destroy_set(set->set); // Release any custom configs if (set->custom) { free(set->custom); } // Release the struct free(set); return; }
int main(int argc, char **argv) { struct set *ss; struct remote *rx; struct katcl_parse *px; struct katcl_line *k; struct timeval delta, start, stop; fd_set fsr, fsw; char *app, *parm, *cmd, *copy, *ptr, *servers, *extra, *label; int i, j, c, fd, mfd, count; int verbose, result, status, info, timeout, flags, show, munge, once; int xmit, code; unsigned int len; servers = getenv("KATCP_SERVER"); if(servers == NULL){ servers = "localhost:7147"; } once = 1; munge = 0; info = 1; verbose = 1; i = j = 1; app = argv[0]; timeout = 0; k = NULL; show = 1; parm = NULL; extra = NULL; label = KCPPAR_NAME; count = 0; px = NULL; k = create_katcl(STDOUT_FILENO); if(k == NULL){ fprintf(stderr, "%s: unable to create katcp message logic\n", app); return 4; } ss = create_set(); if(ss == NULL){ sync_message_katcl(k, KATCP_LEVEL_ERROR, label, "unable to set up command set data structures"); return 4; } xmit = (-1); while (i < argc) { if (argv[i][0] == '-') { c = argv[i][j]; switch (c) { case 'h' : usage(app); return 0; case 'i' : info = 1 - info; j++; break; case 'm' : munge = 1; j++; break; case 'n' : show = 0; j++; break; case 'q' : verbose = 0; j++; break; case 'x' : xmit = 0; j++; break; case 'l' : case 's' : case 't' : j++; if (argv[i][j] == '\0') { j = 0; i++; } if (i >= argc) { sync_message_katcl(k, KATCP_LEVEL_ERROR, label, "argument needs a parameter"); return 2; } switch(c){ case 'l' : label = argv[i] + j; break; case 's' : servers = argv[i] + j; break; case 't' : timeout = atoi(argv[i] + j); break; } i++; j = 1; break; case 'v' : verbose++; j++; break; case '-' : j++; break; case '\0': j = 1; i++; break; default: sync_message_katcl(k, KATCP_LEVEL_ERROR, label, "unknown option -%c", argv[i][j]); return 2; } } else { copy = NULL; if(xmit < 0){ /* WARNING: this could make error detection worse */ xmit = 0; } if(xmit == 0){ px = create_referenced_parse_katcl(); if(px == NULL){ sync_message_katcl(k, KATCP_LEVEL_ERROR, label, "unable to create parse instance for <%s ...>", argv[i]); return 4; } switch(argv[i][0]){ case KATCP_REQUEST : case KATCP_REPLY : case KATCP_INFORM : ptr = argv[i]; break; default : copy = malloc(strlen(argv[i]) + 1); if(copy == NULL){ sync_message_katcl(k, KATCP_LEVEL_ERROR, label, "unable to allocate temporary storage for %s", argv[i]); return 4; } copy[0] = KATCP_REQUEST; strcpy(copy + 1, argv[i]); ptr = copy; break; } flags = KATCP_FLAG_FIRST; } else { ptr = argv[i]; flags = 0; } i++; j = 1; if((i >= argc) || (argv[i][0] == '-')){ flags |= KATCP_FLAG_LAST; } if(add_string_parse_katcl(px, flags, ptr) < 0){ sync_message_katcl(k, KATCP_LEVEL_ERROR, label, "unable to add parameter %s", ptr); return 4; } if(flags & KATCP_FLAG_LAST){ #ifdef DEBUG fprintf(stderr, "par: loading command for servers %s\n", servers); #endif if(load_parse_set(ss, servers, px) < 0){ sync_message_katcl(k, KATCP_LEVEL_ERROR, label, "unable to load command into server set %s", servers); return 4; } destroy_parse_katcl(px); px = NULL; } if(copy){ free(copy); copy = NULL; } xmit++; } } if(timeout == 0){ timeout = 5000 * ss->s_count; } gettimeofday(&start, NULL); delta.tv_sec = timeout / 1000; delta.tv_usec = (timeout % 1000) * 1000; add_time_katcp(&stop, &start, &delta); if(activate_remotes(ss, k) < 0){ sync_message_katcl(k, KATCP_LEVEL_ERROR, label, "unable to initiate connections to remote servers"); return 3; } for(ss->s_finished = 0; ss->s_finished < ss->s_count;){ mfd = 0; FD_ZERO(&fsr); FD_ZERO(&fsw); if(k){ if(flushing_katcl(k)){ mfd = fileno_katcl(k); FD_SET(mfd, &fsw); } } for(i = 0; i < ss->s_count; i++){ rx = ss->s_vector[i]; if(rx->r_line){ fd = fileno_katcl(rx->r_line); if(fd > mfd){ mfd = fd; } } else { fd = (-1); /* WARNING: live dangerously */ } switch(rx->r_state){ case RX_SETUP : FD_SET(fd, &fsw); break; case RX_UP : if(flushing_katcl(rx->r_line)){ /* only write data if we have some */ FD_SET(fd, &fsw); } FD_SET(fd, &fsr); break; /* case RX_OK : */ /* case RX_FAIL : */ /* case RX_BAD : */ default : break; } } gettimeofday(&start, NULL); sub_time_katcp(&delta, &stop, &start); result = select(mfd + 1, &fsr, &fsw, NULL, &delta); switch(result){ case -1 : switch(errno){ case EAGAIN : case EINTR : continue; /* WARNING */ default : sync_message_katcl(k, KATCP_LEVEL_ERROR, label, "select failed: %s", strerror(errno)); return 4; } break; case 0 : sync_message_katcl(k, KATCP_LEVEL_ERROR, label, "requests timed out after %dms", timeout); /* could terminate cleanly here, but ... */ return 3; } if(k){ fd = fileno_katcl(k); if(FD_ISSET(fd, &fsw)){ write_katcl(k); /* WARNING: ignores write failures - unable to do much about it */ } } for(i = 0; i < ss->s_count; i++){ rx = ss->s_vector[i]; if(rx->r_line){ fd = fileno_katcl(rx->r_line); } else { fd = (-1); /* WARNING: live dangerously, will cause select to core dump if logic is incorrect */ } switch(rx->r_state){ case RX_SETUP : if(FD_ISSET(fd, &fsw)){ len = sizeof(int); result = getsockopt(fd, SOL_SOCKET, SO_ERROR, &code, &len); if(result == 0){ switch(code){ case 0 : if(verbose){ log_message_katcl(k, KATCP_LEVEL_DEBUG, label, "async connect to %s succeeded", rx->r_name); } if(next_request(rx) < 0){ log_message_katcl(k, KATCP_LEVEL_ERROR, label, "failed to load request for destination %s", rx->r_name); update_state(ss, rx, RX_BAD); } else { update_state(ss, rx, RX_UP); } break; case EINPROGRESS : log_message_katcl(k, KATCP_LEVEL_WARN, label, "saw an in progress despite write set being ready on job %s", rx->r_name); break; default : log_message_katcl(k, KATCP_LEVEL_ERROR, label, "unable to connect to %s: %s", rx->r_name, strerror(code)); update_state(ss, rx, RX_BAD); break; } } } break; case RX_UP : if(FD_ISSET(fd, &fsw)){ /* flushing things */ result = write_katcl(rx->r_line); if(result < 0){ log_message_katcl(k, KATCP_LEVEL_ERROR, label, "unable to write to %s: %s", rx->r_name, strerror(error_katcl(rx->r_line))); update_state(ss, rx, RX_BAD); } } if(FD_ISSET(fd, &fsr)){ /* get things */ result = read_katcl(rx->r_line); if(result){ if(result < 0){ log_message_katcl(k, KATCP_LEVEL_ERROR, label, "read from %s failed: %s", rx->r_name, strerror(error_katcl(rx->r_line))); } else { log_message_katcl(k, KATCP_LEVEL_WARN, label, "%s disconnected", rx->r_name); } } } while(have_katcl(rx->r_line) > 0){ /* compute */ cmd = arg_string_katcl(rx->r_line, 0); if(cmd){ #ifdef DEBUG fprintf(stderr, "reading message <%s ...>\n", cmd); #endif switch(cmd[0]){ case KATCP_INFORM : if(info){ if(show == 0){ if(!strcmp(KATCP_VERSION_CONNECT_INFORM, cmd)){ break; } if(!strcmp(KATCP_VERSION_INFORM, cmd)){ break; } if(!strcmp(KATCP_BUILD_STATE_INFORM, cmd)){ break; } } relay_katcl(rx->r_line, k); } break; case KATCP_REPLY : switch(cmd[1]){ case ' ' : case '\n' : case '\r' : case '\t' : case '\\' : case '\0' : log_message_katcl(k, KATCP_LEVEL_ERROR, label, "unreasonable response message from %s", rx->r_name); update_state(ss, rx, RX_BAD); break; default : ptr = cmd + 1; if(strcmp(ptr, rx->r_match)){ log_message_katcl(k, KATCP_LEVEL_ERROR, label, "downstream %s returned response %s which was never requested", rx->r_name, ptr); update_state(ss, rx, RX_BAD); } else { parm = arg_string_katcl(rx->r_line, 1); if(parm){ if(strcmp(parm, KATCP_OK) == 0){ count++; if(munge){ log_message_katcl(k, KATCP_LEVEL_INFO, label, "%s %s ok", rx->r_name, ptr); } if(verbose > 1){ log_message_katcl(k, KATCP_LEVEL_TRACE, label, "request %s to %s returned ok", ptr, rx->r_name); } result = next_request(rx); if(result){ if(result < 0){ sync_message_katcl(k, KATCP_LEVEL_ERROR, label, "unable to queue request %s to %s", ptr, rx->r_name); update_state(ss, rx, RX_BAD); } else { update_state(ss, rx, RX_OK); } } } else { if(munge){ extra = arg_string_katcl(rx->r_line, 2); log_message_katcl(k, KATCP_LEVEL_ERROR, label, "%s %s %s (%s)", rx->r_name, ptr, parm, extra ? extra : "no extra information"); } if(verbose > 0){ log_message_katcl(k, KATCP_LEVEL_ERROR, label, "downstream %s unable to process %s with status %s (%s)", rx->r_name, cmd, parm, extra ? extra : "no extra information"); } update_state(ss, rx, RX_FAIL); } } else { log_message_katcl(k, KATCP_LEVEL_ERROR, label, "response %s without status from %s", cmd, rx->r_name); update_state(ss, rx, RX_FAIL); } } break; } break; case KATCP_REQUEST : log_message_katcl(k, KATCP_LEVEL_WARN, label, "encountered unanswerable request %s", cmd); update_state(ss, rx, RX_BAD); break; default : if(once){ log_message_katcl(k, KATCP_LEVEL_WARN, label, "read malformed message %s from %s", cmd, rx->r_name); once = 1; } break; } } } break; /* case RX_OK : */ /* case RX_FAIL : */ /* case RX_BAD : */ default : break; } } } status = ss->s_status; destroy_set(ss); if(verbose){ if(status > 0){ log_message_katcl(k, KATCP_LEVEL_WARN, label, "command sequence failed after operation %d", count); } else { if(count > 0){ log_message_katcl(k, KATCP_LEVEL_INFO, label, "%d operations ok", count); } else { log_message_katcl(k, KATCP_LEVEL_INFO, label, "did nothing successfully"); } } } /* flush, allows us to get away with deferring writes to stdout */ while(write_katcl(k) == 0); destroy_katcl(k, 0); return status; }