/* Insertion never needs more than 2 rotations */
struct avltree_node *avltree_insert(struct avltree_node *node, struct avltree *tree) {
struct avltree_node *parent = 0, *unbalanced = tree->root;
bool is_left;
// Find a suitable parent.
for (struct avltree_node *next_parent = tree->root; next_parent != 0;) {
parent = next_parent;
if (get_balance(parent) != 0)
unbalanced = parent;
int cmp_r = tree->cmp_fn(parent, node);
if (cmp_r == 0) {
if (tree->unique_index)
return parent;
// For non unique indexes any insert direction is acceptable.
if (parent->left == 0) {
is_left = true;
break;
} else if (parent->right == 0) {
is_left = false;
break;
} else {
// Be smart and travel to the least balanced subtree to minimize balancing overhead.
next_parent = (get_balance(parent) <= 0)? parent->left: parent->right;
}
} else {
is_left = (cmp_r > 0);
next_parent = is_left? parent->left: parent->right;
}
}
INIT_NODE(node);
if (!parent) {
tree->root = node;
tree->first = tree->last = node;
tree->height++;
return 0;
}
if (is_left) {
if (parent == tree->first)
tree->first = node;
} else {
if (parent == tree->last)
tree->last = node;
}
set_parent(parent, node);
set_child(node, parent, is_left);
for (;;) {
if (parent->left == node)
dec_balance(parent);
else
inc_balance(parent);
if (parent == unbalanced) {
for (;;) {
node = parent;
node->count++;
if (is_root(node))
break;
parent = get_parent(parent);
}
break;
}
node = parent;
node->count++;
parent = get_parent(parent);
}
switch (get_balance(unbalanced)) {
case 1: case -1:
tree->height++;
/* fall through */
case 0:
break;
case 2:
{
struct avltree_node *right = unbalanced->right;
if (get_balance(right) == 1) {
set_balance(0, unbalanced);
set_balance(0, right);
} else {
switch (get_balance(right->left)) {
case 1:
set_balance(-1, unbalanced);
set_balance(0, right);
break;
case 0:
set_balance(0, unbalanced);
set_balance(0, right);
break;
case -1:
set_balance(0, unbalanced);
set_balance(1, right);
break;
}
set_balance(0, right->left);
rotate_right(right, tree);
}
rotate_left(unbalanced, tree);
break;
}
case -2:
{
struct avltree_node *left = unbalanced->left;
if (get_balance(left) == -1) {
set_balance(0, unbalanced);
set_balance(0, left);
} else {
switch (get_balance(left->right)) {
case 1:
set_balance(0, unbalanced);
set_balance(-1, left);
break;
case 0:
set_balance(0, unbalanced);
set_balance(0, left);
break;
case -1:
set_balance(1, unbalanced);
set_balance(0, left);
break;
}
set_balance(0, left->right);
rotate_left(left, tree);
}
rotate_right(unbalanced, tree);
break;
}
}
return 0;
}
void process_tree(struct rooted_tree *tree, struct parameters params)
{
struct llist *descendants;
switch (params.mode) {
case EXACT:
descendants = nodes_from_labels(tree, params.labels);
if (NULL == descendants) { perror(NULL); exit(EXIT_FAILURE); }
if (0 == descendants->count) {
fprintf (stderr, "WARNING: no label matches.\n");
/* I don't consider this a failure: it is just the case
* that the tree does not contain the specified labels.
* */
exit(EXIT_SUCCESS);
}
break;
case REGEXP:
descendants = nodes_from_regexp(tree, params.regexp);
if (NULL == descendants) { perror(NULL); exit(EXIT_FAILURE); }
if (0 == descendants->count) {
fprintf (stderr, "WARNING: no match for regexp /%s/\n",
params.regexp_string);
exit(EXIT_SUCCESS); /** see above */
}
break;
default:
fprintf (stderr, "Unknown mode %d\n", params.mode);
exit(EXIT_FAILURE);
}
/* We need a copy b/c lca() modifies its arg */
struct llist *desc_clone = shallow_copy(descendants);
if (NULL == desc_clone) { perror(NULL); exit(EXIT_FAILURE); }
struct rnode *subtree_root = lca(tree, desc_clone);
if (NULL == subtree_root) { perror(NULL); exit(EXIT_FAILURE); }
free(desc_clone); /* elems freed in lca() */
/* Jump up tree to get context, if any was required ('context' > 0) */
int context;
for (context = params.context; context > 0; context--)
if (! is_root(subtree_root))
subtree_root = subtree_root->parent;
// TODO: could not replace to_newick() by dump_newick() due to side
// effects. Investigate.
if (NULL != subtree_root) {
if ((! params.check_monophyly) ||
(is_monophyletic(descendants, subtree_root))) {
/* monophyly of input labels is verified or not
* requested */
char *newick;
if (params.siblings) {
struct llist *sibs = siblings(subtree_root);
if (NULL == sibs) {
perror(NULL);
exit(EXIT_FAILURE);
}
struct list_elem *el;
for (el=sibs->head;NULL!=el;el=el->next) {
struct rnode *sib;
sib = el->data;
newick = to_newick(sib);
printf ("%s\n", newick);
free(newick);
}
destroy_llist(sibs);
} else {
/* normal operation: print clade defined by
* labels. */
newick = to_newick(subtree_root);
printf ("%s\n", newick);
free(newick);
}
}
} else {
fprintf (stderr, "WARNING: LCA not found\n");
}
destroy_llist(descendants);
}
void draw_branches_ortho (struct rooted_tree *tree, const double h_scale,
const double v_scale, int align_leaves, double dmax)
{
printf("<g "
" style='stroke:black;fill:none;stroke-width:1;"
"stroke-linecap:round'>"
);
struct list_elem *elem;
for (elem=tree->nodes_in_order->head; NULL!=elem; elem=elem->next) {
struct rnode *node = elem->data;
struct svg_data *node_data = (struct svg_data *) node->data;
/* For cladograms */
if (align_leaves && is_leaf(node))
node_data->depth = dmax;
double svg_h_pos = ROOT_SPACE + (h_scale * node_data->depth);
double svg_top_pos = v_scale * node_data->top;
double svg_bottom_pos = v_scale * node_data->bottom;
double svg_mid_pos =
0.5 * v_scale * (node_data->top+node_data->bottom);
/* draw node (vertical line), except for leaves */
if (! is_leaf(node)) {
printf("<line class='clade_%d' "
"x1='%.4f' y1='%.4f' x2='%.4f' y2='%.4f'/>",
node_data->group_nb, svg_h_pos, svg_top_pos, svg_h_pos,
svg_bottom_pos);
}
/* draw horizontal line */
if (is_root(node)) {
printf("<line x1='0' y1='%.4f' x2='%.4f' y2='%.4f'/>",
svg_mid_pos, svg_h_pos, svg_mid_pos);
} else {
struct svg_data *parent_data = node->parent->data;
double svg_parent_h_pos = ROOT_SPACE + (
h_scale * parent_data->depth);
printf ("<line class='clade_%d' "
"x1='%.4f' y1='%.4f' x2='%.4f' y2='%.4f'/>",
node_data->group_nb, svg_parent_h_pos,
svg_mid_pos, svg_h_pos, svg_mid_pos);
}
/* draw ornament, if any */
if (NULL != node_data->ornament) {
/* ornament is considered text IFF it starts
* with "<text" */
if (strstr(node_data->ornament, "<text") ==
node_data->ornament) {
printf ("<g style='text-anchor:end;"
"stroke:none;fill:black'"
" transform='"
"translate(%g,%g)'>%s</g>",
svg_h_pos,
svg_mid_pos + edge_length_v_offset,
node_data->ornament);
} else { /* not text */
printf ("<g transform='"
"translate(%g,%g)'>%s</g>",
svg_h_pos, svg_mid_pos,
node_data->ornament);
}
}
}
printf("</g>");
}
void MPILock::add_resource(Resource resource, unsigned tokens) {
resources[resource] = new MPIResource(resource, sides.size(), tokens, is_root());
}
int
store_cred(const char* user, const char* pw, int mode, Daemon* d, bool force) {
int result;
int return_val;
Sock* sock = NULL;
// to help future debugging, print out the mode we are in
static const int mode_offset = 100;
static const char *mode_name[] = {
ADD_CREDENTIAL,
DELETE_CREDENTIAL,
QUERY_CREDENTIAL
#ifdef WIN32
, CONFIG_CREDENTIAL
#endif
};
dprintf ( D_ALWAYS,
"STORE_CRED: In mode '%s'\n",
mode_name[mode - mode_offset] );
// If we are root / SYSTEM and we want a local daemon,
// then do the work directly to the local registry.
// If not, then send the request over the wire to a remote credd or schedd.
if ( is_root() && d == NULL ) {
// do the work directly onto the local registry
return_val = store_cred_service(user,pw,mode);
} else {
// send out the request remotely.
// first see if we're operating on the pool password
int cmd = STORE_CRED;
char const *tmp = strchr(user, '@');
if (tmp == NULL || tmp == user || *(tmp + 1) == '\0') {
dprintf(D_ALWAYS, "store_cred: user not in user@domain format\n");
return FAILURE;
}
if (((mode == ADD_MODE) || (mode == DELETE_MODE)) &&
( (size_t)(tmp - user) == strlen(POOL_PASSWORD_USERNAME)) &&
(memcmp(POOL_PASSWORD_USERNAME, user, tmp - user) == 0))
{
cmd = STORE_POOL_CRED;
user = tmp + 1; // we only need to send the domain name for STORE_POOL_CRED
}
if (d == NULL) {
if (cmd == STORE_POOL_CRED) {
// need to go to the master for setting the pool password
dprintf(D_FULLDEBUG, "Storing credential to local master\n");
Daemon my_master(DT_MASTER);
sock = my_master.startCommand(cmd, Stream::reli_sock, 0);
}
else {
dprintf(D_FULLDEBUG, "Storing credential to local schedd\n");
Daemon my_schedd(DT_SCHEDD);
sock = my_schedd.startCommand(cmd, Stream::reli_sock, 0);
}
} else {
dprintf(D_FULLDEBUG, "Starting a command on a REMOTE schedd\n");
sock = d->startCommand(cmd, Stream::reli_sock, 0);
}
if( !sock ) {
dprintf(D_ALWAYS,
"STORE_CRED: Failed to start command.\n");
dprintf(D_ALWAYS,
"STORE_CRED: Unable to contact the REMOTE schedd.\n");
return FAILURE;
}
// for remote updates (which send the password), verify we have a secure channel,
// unless "force" is specified
if (((mode == ADD_MODE) || (mode == DELETE_MODE)) && !force && (d != NULL) &&
((sock->type() != Stream::reli_sock) || !((ReliSock*)sock)->triedAuthentication() || !sock->get_encryption())) {
dprintf(D_ALWAYS, "STORE_CRED: blocking attempt to update over insecure channel\n");
delete sock;
return FAILURE_NOT_SECURE;
}
if (cmd == STORE_CRED) {
result = code_store_cred(sock, const_cast<char*&>(user),
const_cast<char*&>(pw), mode);
if( result == FALSE ) {
dprintf(D_ALWAYS, "store_cred: code_store_cred failed.\n");
delete sock;
return FAILURE;
}
}
else {
// only need to send the domain and password for STORE_POOL_CRED
if (!sock->code(const_cast<char*&>(user)) ||
!sock->code(const_cast<char*&>(pw)) ||
!sock->end_of_message()) {
dprintf(D_ALWAYS, "store_cred: failed to send STORE_POOL_CRED message\n");
delete sock;
return FAILURE;
}
}
sock->decode();
result = sock->code(return_val);
if( !result ) {
dprintf(D_ALWAYS, "store_cred: failed to recv answer.\n");
delete sock;
return FAILURE;
}
result = sock->end_of_message();
if( !result ) {
dprintf(D_ALWAYS, "store_cred: failed to recv eom.\n");
delete sock;
return FAILURE;
}
} // end of case where we send out the request remotely
switch(mode)
{
case ADD_MODE:
if( return_val == SUCCESS ) {
dprintf(D_FULLDEBUG, "Addition succeeded!\n");
} else {
dprintf(D_FULLDEBUG, "Addition failed!\n");
}
break;
case DELETE_MODE:
if( return_val == SUCCESS ) {
dprintf(D_FULLDEBUG, "Delete succeeded!\n");
} else {
dprintf(D_FULLDEBUG, "Delete failed!\n");
}
break;
case QUERY_MODE:
if( return_val == SUCCESS ) {
dprintf(D_FULLDEBUG, "We have a credential stored!\n");
} else {
dprintf(D_FULLDEBUG, "Query failed!\n");
}
break;
}
if ( sock ) delete sock;
return return_val;
}
