void update_arp_queue(struct sr_instance* sr, arp_hdr* arp_header, const char* interface) {
router_state* rs = get_router_state(sr);
node* n = rs->arp_queue;
node* next = NULL;
while (n) {
next = n->next;
arp_queue_entry* aqe = (arp_queue_entry*)n->data;
/* Does this arp reply match an entry waiting for it? */
if (arp_header->arp_sip.s_addr == aqe->next_hop.s_addr) {
/* send out the packets */
node* cur_packet_node = aqe->head;
node* next_packet_node = NULL;
while (cur_packet_node) {
next_packet_node = cur_packet_node->next;
arp_queue_packet_entry* aqpe = (arp_queue_packet_entry*)cur_packet_node->data;
/* send_ip takes responsibility for the packet so we don't need to free it */
send_ip(sr, aqpe->packet, aqpe->len, &(aqe->next_hop), aqe->out_iface_name);
node_remove(&(aqe->head), cur_packet_node);
cur_packet_node = next_packet_node;
}
node_remove(&(rs->arp_queue), n);
}
n = next;
}
}
static node_t *node_remove(tree_t *tree, node_t *p, const int key)
{
if (!IS_NIL(p)) {
int d = tree->compare(key, p->key);
if (d == 0) {
if (IS_NIL(p->left)) {
node_t *q = p->right;
node_destroy(tree, p);
return q;
} else if (IS_NIL(p->right)) {
node_t *q = p->left;
node_destroy(tree, p);
return q;
} else {
node_t *q = p;
node_t *r = node_remove_swap(tree, p->right,
&q);
p = q;
p->right = r;
}
} else if (d < 0)
p->left = node_remove(tree, p->left, key);
else
p->right = node_remove(tree, p->right, key);
p = node_rebalance(p);
}
return p;
}
/*
* NOT THREAD SAFE! Lock cache rd, queue wr
*
*
*/
void send_queued_packets(struct sr_instance* sr, struct in_addr* dest_ip, char* dest_mac) {
node* n = get_router_state(sr)->arp_queue;
node* next = NULL;
while (n) {
next = n->next;
arp_queue_entry* aqe = (arp_queue_entry*)n->data;
/* match the arp reply sip to our entry next hop ip */
if (dest_ip->s_addr == aqe->next_hop.s_addr) {
node* cur_packet_node = aqe->head;
node* next_packet_node = NULL;
while (cur_packet_node) {
next_packet_node = cur_packet_node->next;
/* send the packet */
arp_queue_packet_entry* aqpe = (arp_queue_packet_entry*)cur_packet_node->data;
send_ip(sr, aqpe->packet, aqpe->len, &(aqe->next_hop), aqe->out_iface_name);
node_remove(&(aqe->head), cur_packet_node);
cur_packet_node = next_packet_node;
}
/* free the arp queue entry for this destination ip, and patch the list */
node_remove(&(get_router_state(sr)->arp_queue), n);
}
n = next;
}
}
static inline
avl_tree_node_t *node_remove(avl_tree_node_t *n, avl_tree_key_t k,
bool *removed,
void **_data) {
avl_tree_node_t copy, *min;
bool n_is_left = false;
if (!n)
return NULL;
if (k < n->key)
n->left = node_remove(n->left, k, removed, _data);
else if (k > n->key)
n->right = node_remove(n->right, k, removed, _data);
else {
*removed = true;
*_data = n->data;
n_is_left = node_is_left(n);
copy = *n;
node_operators[n->host->inplace].deallocator(n);
if (!copy.right) {
if (copy.left)
copy.left->parent = copy.parent;
return copy.left;
}
min = node_leftmost(copy.right);
min->right = node_remove_min(copy.right);
min->left = copy.left;
min->parent = copy.parent;
if (min->parent) {
if (n_is_left)
min->parent->left = min;
else
min->parent->right = min;
}
if (min->left)
min->left->parent = min;
if (min->right)
min->right->parent = min;
return node_balance(min);
}
return node_balance(n);
}
void pending_request_remove_and_free(PendingRequest *pending_request) {
node_remove(&pending_request->global_node);
node_remove(&pending_request->client_node);
if (pending_request->client != NULL) {
--pending_request->client->pending_request_count;
}
if (pending_request->zombie != NULL) {
--pending_request->zombie->pending_request_count;
}
free(pending_request);
}
nth_desc_t* nth_desc_edlist_get_front (nth_desc_edlist_t *l, int state,
nth_desc_t *from )
{
int vp = from->vp;
nth_player_t *player = from->player;
nth_desc_t *rv=NULL;
if (l->first) {
nth_spin_lock(&l->mutex);
rv = l->first;
while (rv) {
if ( rv->state == state )
// To be included in next revision
// && (!rv->player || rv->player->team == team )
if ( !rv->tied || rv->vp == vp )
break;
rv = rv->next;
}
if (rv) {
node_remove(l,rv);
}
nth_spin_unlock(&l->mutex);
}
return rv;
}
/*
* HELPER function called from arp_thread
* NOT THREAD SAFE
*/
void expire_arp_cache(struct sr_instance* sr) {
assert(sr);
router_state *rs = (router_state *)sr->interface_subsystem;
node *arp_walker = 0;
arp_cache_entry *arp_entry = 0;
time_t now;
double diff;
int timedout_entry = 0;
arp_walker = rs->arp_cache;
while(arp_walker) {
arp_entry = (arp_cache_entry *)arp_walker->data;
node *tmp = arp_walker;
arp_walker = arp_walker->next;
/** if not static, check that is TTL is within reason **/
if (arp_entry->is_static != 1) {
time(&now);
diff = difftime(now, arp_entry->TTL);
if (diff > rs->arp_ttl) {
node_remove(&rs->arp_cache, tmp);
timedout_entry = 1;
}
}
}
/* update the hw arp cache */
if(timedout_entry == 1) {
trigger_arp_cache_modified(rs);
}
}
nth_desc_t* nth_desc_edlist_get_back (nth_desc_edlist_t *l, int state,
nth_desc_t *from)
{
int vp = from->vp;
nth_player_t *player = from->player;
nth_desc_t *rv=NULL;
if (l->last) {
nth_spin_lock(&l->mutex);
rv = l->last;
while (rv) {
if ( rv->state == state )
// && (!rv->player || rv->player->team == team ) )
if ( !rv->tied || rv->vp == vp )
break;
rv = rv->prev;
}
if (rv) {
node_remove(l,rv);
}
nth_spin_unlock(&l->mutex);
}
return rv;
}
static void* save_state_cmd (int argc, char **argv, void *data)
{
Node *pos = (Node *) data;
Node *i;
Node *j;
if (savedtree != NULL) {
tree_free (savedtree);
}
savedtree = node_new ();
i = node_root (pos);
j = savedtree;
do {
j = savedtree = tree_duplicate (i, j);
i = node_down (i);
j = node_insert_down (j);
} while (i != NULL);
j = node_remove (j);
{
int no;
no = node_no (pos);
savedtree = node_root (savedtree);
while (--no)
savedtree = node_recurse (savedtree);
}
return pos;
}
void trie_done(trie_tree *tree)
{
assert(tree != NULL);
if(tree->root != NULL)
node_remove(tree->root);
free(tree);
}
/**
Usuwa poddrzewo node'a
@param[in,out] node Węzeł
*/
static void node_remove(trie_node *node)
{
assert(node != NULL);
for(int i = 0 ; i < vector_size(node->sons); i++)
node_remove(NTH_SON(node, i));
vector_done(node->sons);
free(node);
}
node_t *tree_remove(tree_t *tree, int key)
{
node_t *n = tree_search(tree, key);
if (n == tree->root)
tree->root = NULL;
return (!is_nil(n)) ? (node_remove(n)) : NULL;
}
int main(int argc, char* argv[]) {
int i, j, k;
char c;
node *head = (node*) malloc(sizeof(node)); // 헤드 노드 생성
head->next = NULL; // 잘못된 주소 할당 방지 위해 next 포인터 0x0 으로 만들어 놓기 -> head 노드가 노드의 끝이라는 것 명시
printf("Main: %p, %p\n", head, head->next); // 헤드 노드 및 next 포인터 프린트
while(1) {
printf("Input command(I: insert, A: append, C: Append sequentially, D: delete, P: print, R: print all. E: exit.\n");
scanf(" %c", &c);
if(c =='E' || c == 'e') break;
switch(c) {
case 'I':
case 'i':
printf("Input number and position (For example, 4 5 measn put number 4 in fifth node)\n");
scanf("%d %d", &i, &j);
node_insert(head, i, j);
break;
case 'A' :
case 'a' :
printf("Input number (for example, 4 means append number 4)\n");
scanf("%d", &i);
node_append(head, i);
break;
case 'C' :
case 'c' :
printf("Input number (for example, 4 8 means append number 4 5 6 7 8 in a row)\n");
scanf("%d %d", &i, &j);
for(k=i; k<=j; k++)
node_append(head, k);
break;
case 'D' :
case 'd' :
printf("Input node position to delete (For example, 5 means delete node in postition 5)\n");
scanf("%d", &i);
node_remove(head, i);
break;
case 'P' :
case 'p' :
printf("Input node position to print(For example, 5 means print number in fifth node)\n");
scanf("%d", &i);
node_print(head, i);
break;
case 'R' :
case 'r' :
node_print_all(head);
break;
}
}
free(head);
return 0;
}
/**
Próbuje usunąć węzeł
@param[in,out] node Węzeł
@return NULL jeżeli node został usunięty, node w p. p.
*/
static trie_node * node_try_to_delete(trie_node *node)
{
assert(node != NULL);
if(!node->end_of_word && vector_size(node->sons) == 0)
{
node_remove(node);
return NULL;
}
return node;
}
nth_desc_t * nth_desc_dlist_pop_back ( nth_desc_dlist_t *l )
{
nth_desc_t *nth;
nth = l->last;
if ( nth ) {
node_remove(l,nth);
}
return nth;
}
nth_desc_t * nth_desc_dlist_pop_front ( nth_desc_dlist_t *l )
{
nth_desc_t *nth;
nth = l->first;
if ( nth ) {
node_remove(l,nth);
}
return nth;
}
/* removes *pos if it is a temporary node, then returns 1
* otherwize returns 0
*/
static int remove_temp (Node **pos)
{
if (node_getflag (*pos, F_temp)) {
*pos = node_remove ((*pos));
node_update_parents_todo ((*pos));
docmd(*pos,"tree_changed");
return 1;
}
return 0;
}
Article* queue_pop(Queue *queue) {
if (!queue_isempty(queue)) {
Article *ptr = node_get_ptr(queue->top);
Node *old_top = queue->top;
queue->top = node_get_next(queue->top);
node_remove(old_top); // Don't delete article in the node
queue->size--;
return ptr;
}
return 0;
}
void avl_tree_remove(avl_tree_t *t, avl_tree_key_t k) {
void *d;
bool removed = false;
assert(t);
t->root = node_remove(t->root, k, &removed, &d);
if (removed)
--t->count;
}
static int cut_cmd (int argc,char **argv, void *data)
{
Node *pos = (Node *) data;
if (clipboard != NULL) {
tree_free (clipboard);
}
clipboard = node_new ();
clipboard = tree_duplicate (pos, clipboard);
pos = node_remove (pos);
return (int) pos;
}
nth_desc_t * nth_desc_edlist_pop_back ( nth_desc_edlist_t *l )
{
nth_desc_t *nth=0;
if ( l->last ) {
nth_spin_lock(&l->mutex);
nth = l->last;
if ( nth ) {
node_remove(l,nth);
}
nth_spin_unlock(&l->mutex);
}
return nth;
}
node_t *node_remove(node_t *n)
{
if (is_leaf(n))
{
// przypadek 1: jest liściem
// usuń wskaźnik z ojca
if (is_left_child(n))
parent(n)->left = NULL;
else
parent(n)->right = NULL;
}
else if (has_one_child(n))
{
// przypadek 2: tylko jedno dziecko
node_t *child = (!is_nil(n->left)) ? (n->left) : (n->right);
// niech dziadek stanie się ojcem
parent(child) = parent(n);
// podczep dziecko jako lewego lub prawego syna rodzica usuwanego węzła
if (is_left_child(n))
parent(child)->left = child;
else
parent(child)->right = child;
}
else
{
// przypadek 3: dwoje dzieci
// znajdź poprzednika
node_t *next = n->left;
while (!is_nil(next->right))
next = next->right;
// zamień dane następnika z węzłem
node_swap_data(next, n);
n = node_remove(next);
}
n->left = NULL;
n->right = NULL;
parent(n) = NULL;
return n;
}
static void* cut_cmd (int argc,char **argv, void *data)
{
Node *pos = (Node *) data;
if(prefs.readonly){
cli_outfun("readonly flag set, avoiding tree change");
return data;
}
if (clipboard != NULL) {
tree_free (clipboard);
}
clipboard = node_new ();
clipboard = tree_duplicate (pos, clipboard);
pos = node_remove (pos);
docmd(pos,"tree_changed");
return pos;
}
nth_desc_t * nth_desc_edlist_remove ( nth_desc_t *node, nth_desc_edlist_t *wh )
{
volatile nth_desc_edlist_t *l;
if ( !(l=node->myqueue) ) return NULL;
if ( wh && l != wh ) return NULL;
nth_assert(l,"null my queue");
nth_spin_lock(&l->mutex);
if ( node->myqueue == l && (!wh || l == wh)) {
nth_assert(l==node->myqueue,"l=%p myqueue=%p",l,node->myqueue);
node_remove(l,node);
} else node = NULL;
nth_spin_unlock(&l->mutex);
return node;
}
void *avl_tree_remove_get_data(avl_tree_t *t, avl_tree_key_t k) {
void *d = NULL;
bool removed = false;
assert(t);
#if 0
n = node_get(t->root, k);
d = n->data;
#endif
t->root = node_remove(t->root, k, &removed, &d);
if (removed)
--t->count;
return d;
}
void
feedlist_node_removed (nodePtr node)
{
if (node == SELECTED)
feedlist_unselect ();
/* First remove all children */
node_foreach_child (node, feedlist_node_removed);
node_remove (node);
ui_node_remove_node (node);
node->parent->children = g_slist_remove (node->parent->children, node);
node_free (node);
feedlist_schedule_save ();
}
/*
* NOT THREAD SAFE
* Returns: # of deleted arp cache entries (should only be 1)
*/
int del_arp_cache(struct sr_instance* sr, struct in_addr* ip) {
router_state* rs = get_router_state(sr);
node* cur = rs->arp_cache;
node* next = NULL;
int retval = 0;
while (cur) {
next = cur->next;
arp_cache_entry* entry = (arp_cache_entry*)cur->data;
if (entry->ip.s_addr == ip->s_addr) {
node_remove(&(rs->arp_cache), cur);
++retval;
}
cur = next;
}
return retval;
}
STATIC VOID MultiString_Event(void **msg)
{
/* struct IClass *cl = (struct IClass*)msg[0];*/
Object *obj = (Object*)msg[1];
struct object_node *obj_node = (struct object_node*)msg[2];
Object *window = (Object*)xget(obj,MUIA_WindowObject);
int event = (int)msg[3];
if (event == MUIV_SingleString_Event_CursorUp && node_prev(&obj_node->node))
{
set(window, MUIA_Window_ActiveObject, ((struct object_node*)node_prev(&obj_node->node))->obj);
return;
}
if (event == MUIV_SingleString_Event_CursorDown && node_next(&obj_node->node))
{
set(window, MUIA_Window_ActiveObject, ((struct object_node*)node_next(&obj_node->node))->obj);
return;
}
if (event == MUIV_SingleString_Event_ContentsToPrevLine && node_prev(&obj_node->node))
{
struct object_node *prev_node = (struct object_node*)node_prev(&obj_node->node);
char *contents = (char*)xget(obj_node->obj, MUIA_UTF8String_Contents);
int new_cursor_pos = strlen((char*)xget(prev_node->obj, MUIA_String_Contents)); /* is Okay */
DoMethod(prev_node->obj, MUIM_UTF8String_Insert, (ULONG)contents, MUIV_BetterString_Insert_EndOfString);
set(prev_node-> obj,MUIA_String_BufferPos, new_cursor_pos);
set(window, MUIA_Window_ActiveObject, prev_node->obj);
node_remove(&obj_node->node);
DoMethod(obj, MUIM_Group_InitChange);
DoMethod(obj, OM_REMMEMBER, (ULONG)obj_node->obj);
MUI_DisposeObject(obj_node->obj);
free(obj_node);
DoMethod(obj, MUIM_Group_ExitChange);
return;
}
}
void cli_nuke_arp_cache(router_state *rs, cli_request *req) {
lock_arp_cache_wr(rs);
/* destroy the sw arp cache */
node *cur = rs->arp_cache;
while(cur) {
node *next = cur->next;
node_remove(&rs->arp_cache, cur);
cur = next;
}
/* zero out the hw arp cache */
if(rs->is_netfpga) {
trigger_arp_cache_modified(rs);
}
unlock_arp_cache(rs);
char *info = "SW and HW arp cache info was nuked\n";
send_to_socket(req->sockfd, info, strlen(info));
}
void libusb_close(libusb_device_handle *dev_handle) {
libusb_device *dev = dev_handle->dev;
libusb_context *ctx = dev->ctx;
jmethodID close_device_mid;
if (!dev_handle->disconnected && ctx->pollfd_removed_callback != NULL) {
ctx->pollfd_removed_callback(dev_handle->pollfd.fd, ctx->pollfd_user_data);
}
usbi_log_debug(ctx, "Closing device %p (context: %p, name: %s, fd: %d)",
dev, ctx, dev->name, dev_handle->pollfd.fd);
close_device_mid = (*android_env)->GetMethodID(android_env, (*android_env)->GetObjectClass(android_env, android_service),
"closeDevice", "(I)V"); // FIXME: check result
(*android_env)->CallVoidMethod(android_env, android_service, close_device_mid, dev_handle->pollfd.fd); // FIXME: check result
node_remove(&dev_handle->node);
--ctx->dev_handle_count;
libusb_unref_device(dev_handle->dev);
free(dev_handle);
}
