uint8_t bootstrap_handleDeleteAll(lwm2m_context_t * contextP,
void * fromSessionH)
{
lwm2m_server_t * serverP;
uint8_t result;
lwm2m_object_t * objectP;
LOG("Entering");
serverP = utils_findBootstrapServer(contextP, fromSessionH);
if (serverP == NULL) return COAP_IGNORE;
result = prv_checkServerStatus(serverP);
if (result != COAP_NO_ERROR) return result;
result = COAP_202_DELETED;
for (objectP = contextP->objectList; objectP != NULL; objectP = objectP->next)
{
lwm2m_uri_t uri;
memset(&uri, 0, sizeof(lwm2m_uri_t));
uri.flag = LWM2M_URI_FLAG_OBJECT_ID;
uri.objectId = objectP->objID;
if (objectP->objID == LWM2M_SECURITY_OBJECT_ID)
{
lwm2m_list_t * instanceP;
instanceP = objectP->instanceList;
while (NULL != instanceP
&& result == COAP_202_DELETED)
{
if (instanceP->id == serverP->secObjInstID)
{
instanceP = instanceP->next;
}
else
{
uri.flag = LWM2M_URI_FLAG_OBJECT_ID | LWM2M_URI_FLAG_INSTANCE_ID;
uri.instanceId = instanceP->id;
result = object_delete(contextP, &uri);
instanceP = objectP->instanceList;
}
}
if (result == COAP_202_DELETED)
{
prv_tagAllServer(contextP, serverP);
}
}
else
{
result = object_delete(contextP, &uri);
if (result == COAP_405_METHOD_NOT_ALLOWED)
{
// Fake a successful deletion for static objects like the Device object.
result = COAP_202_DELETED;
}
}
}
return result;
}
void saImmOmCcbObjectModify_2_18(void)
{
const SaImmAdminOwnerNameT adminOwnerName = (SaImmAdminOwnerNameT) __FUNCTION__;
SaImmAdminOwnerHandleT ownerHandle;
SaImmCcbHandleT ccbHandle;
const SaNameT obj1 = { strlen("id=1"), "id=1" };
const SaNameT obj2 = { strlen("id=2"), "id=2" };
const SaNameT* attrValues[] = { &obj1 };
SaImmAttrValuesT_2 v1 = { "attr1", SA_IMM_ATTR_SANAMET, 1, (void**)attrValues };
SaImmAttrModificationT_2 attrMod = { SA_IMM_ATTR_VALUES_REPLACE, v1 };
const SaImmAttrModificationT_2 *attrMods[] = { &attrMod, NULL };
safassert(saImmOmInitialize(&immOmHandle, NULL, &immVersion), SA_AIS_OK);
safassert(saImmOmAdminOwnerInitialize(immOmHandle, adminOwnerName, SA_TRUE, &ownerHandle), SA_AIS_OK);
safassert(nodangling_class_create(immOmHandle), SA_AIS_OK);
safassert(object_create(immOmHandle, ownerHandle, nodanglingClassName, &obj1, NULL, NULL), SA_AIS_OK);
safassert(object_create(immOmHandle, ownerHandle, nodanglingClassName, &obj2, NULL, NULL), SA_AIS_OK);
safassert(saImmOmCcbInitialize(ownerHandle, 0, &ccbHandle), SA_AIS_OK);
safassert(object_delete_2(ccbHandle, &obj1, 1), SA_AIS_OK);
rc = saImmOmCcbObjectModify_2(ccbHandle, &obj2, attrMods);
safassert(saImmOmCcbFinalize(ccbHandle), SA_AIS_OK);
safassert(object_delete(ownerHandle, &obj2, 1), SA_AIS_OK);
safassert(object_delete(ownerHandle, &obj1, 1), SA_AIS_OK);
safassert(nodangling_class_delete(immOmHandle), SA_AIS_OK);
safassert(saImmOmAdminOwnerFinalize(ownerHandle), SA_AIS_OK);
safassert(saImmOmFinalize(immOmHandle), SA_AIS_OK);
test_validate(rc, SA_AIS_ERR_BAD_OPERATION);
}
struct _list * elf64_entries (const struct _buffer * buffer)
{
if (elf64_check(buffer))
return NULL;
Elf64_Ehdr * ehdr = elf64_ehdr(buffer);
if (ehdr == NULL)
return NULL;
struct _list * entries = list_create();
struct _index * index = index_create(ehdr->e_entry);
list_append(entries, index);
object_delete(index);
size_t shdr_i;
for (shdr_i = 0; shdr_i < ehdr->e_shnum; shdr_i++) {
size_t sym_i = 0;
Elf64_Sym * sym;
while ((sym = elf64_sym(buffer, shdr_i, sym_i++)) != NULL) {
if ( (ELF64_ST_TYPE(sym->st_info) == STT_FUNC)
&& (sym->st_value != 0)) {
struct _index * index = index_create(sym->st_value);
list_append(entries, index);
object_delete(index);
}
}
}
return entries;
}
struct _map * rdis_g_references (struct _rdis * rdis)
{
struct _map * references = map_create();
struct _graph_it * git;
// for each node
for (git = graph_iterator(rdis->graph); git != NULL; git = graph_it_next(git)) {
struct _graph_node * node = graph_it_node(git);
struct _list_it * lit;
// for each instruction
for (lit = list_iterator(node->data); lit != NULL; lit = lit->next) {
struct _ins * ins = lit->data;
struct _list_it * rit;
// for each reference
for (rit = list_iterator(ins->references); rit != NULL; rit = rit->next) {
struct _reference * reference = rit->data;
int delete_reference = 0;
if (reference->type == REFERENCE_CONSTANT) {
uint64_t lower = map_fetch_max_key(rdis->memory, reference->address);
struct _buffer * buffer = map_fetch(rdis->memory, lower);
if (buffer == NULL)
continue;
uint64_t upper = lower + buffer->size;
if ( (reference->address < lower)
|| (reference->address >= upper))
continue;
reference = object_copy(reference);
reference->type = REFERENCE_CONSTANT_ADDRESSABLE;
delete_reference = 1;
}
struct _list * ref_list = map_fetch(references, reference->address);
if (ref_list == NULL) {
ref_list = list_create();
map_insert(references, reference->address, ref_list);
object_delete(ref_list);
ref_list = map_fetch(references, reference->address);
}
list_append(ref_list, reference);
if (delete_reference)
object_delete(reference);
}
}
}
return references;
}
/**
* Describe the kind
*/
static void kind_info(char *buf, size_t buf_len, char *dam, size_t dam_len,
char *wgt, size_t wgt_len, int *lev, s32b *val, int k)
{
struct object_kind *kind = &k_info[k];
struct object *obj = object_new(), *known_obj = object_new();
int i;
/* Prepare a fake item */
object_prep(obj, kind, 0, MAXIMISE);
/* Cancel bonuses */
for (i = 0; i < OBJ_MOD_MAX; i++)
obj->modifiers[i] = 0;
obj->to_a = 0;
obj->to_h = 0;
obj->to_d = 0;
/* Level */
(*lev) = kind->level;
/* Make known */
object_copy(known_obj, obj);
obj->known = known_obj;
/* Value */
(*val) = object_value(obj, 1, false);
/* Description (too brief) */
if (buf)
object_desc(buf, buf_len, obj, ODESC_BASE | ODESC_SPOIL);
/* Weight */
if (wgt)
strnfmt(wgt, wgt_len, "%3d.%d", obj->weight / 10, obj->weight % 10);
/* Hack */
if (!dam)
return;
/* Misc info */
dam[0] = '\0';
/* Damage */
if (tval_is_ammo(obj) || tval_is_melee_weapon(obj))
strnfmt(dam, dam_len, "%dd%d", obj->dd, obj->ds);
else if (tval_is_armor(obj))
strnfmt(dam, dam_len, "%d", obj->ac);
object_delete(&known_obj);
object_delete(&obj);
}
/**
* Melee effect handler: Eat the player's food.
*/
static void melee_effect_handler_EAT_FOOD(melee_effect_handler_context_t *context)
{
/* Steal some food */
int tries;
/* Take damage */
take_hit(context->p, context->damage, context->ddesc);
/* Player is dead */
if (context->p->is_dead)
return;
for (tries = 0; tries < 10; tries++) {
/* Pick an item from the pack */
int index = randint0(z_info->pack_size);
struct object *obj, *eaten;
char o_name[80];
bool none_left = false;
/* Get the item */
obj = context->p->upkeep->inven[index];
/* Skip non-objects */
if (obj == NULL) continue;
/* Skip non-food objects */
if (!tval_is_edible(obj)) continue;
if (obj->number == 1) {
object_desc(o_name, sizeof(o_name), obj, ODESC_BASE);
msg("Your %s (%c) was eaten!", o_name, I2A(index));
} else {
object_desc(o_name, sizeof(o_name), obj,
ODESC_PREFIX | ODESC_BASE);
msg("One of your %s (%c) was eaten!", o_name,
I2A(index));
}
/* Steal and eat */
eaten = gear_object_for_use(obj, 1, false, &none_left);
if (eaten->known)
object_delete(&eaten->known);
object_delete(&eaten);
/* Obvious */
context->obvious = true;
/* Done */
break;
}
}
/* code_delete */
int code_delete(Code * code)
{
int ret = 0;
CodeScope * scope;
size_t i;
DEBUG_FUNC();
if(code->plugin != NULL)
{
if(code->target != NULL)
ret = _code_target_exit(code);
plugin_delete(code->plugin);
}
/* free the context */
_code_context_flush(code);
/* free the scopes */
/* do it ourselves as code_scope_pop() stops at the global */
for(; code->scopes_cnt > 0; code->scopes_cnt--)
{
scope = &code->scopes[code->scopes_cnt - 1];
for(i = 0; i < scope->variables_cnt; i++)
free(scope->variables[i].name);
free(scope->variables);
}
free(code->scopes);
/* free the types */
for(i = 0; i < code->types_cnt; i++)
free(code->types[i].name);
free(code->types);
object_delete(code);
return ret;
}
/* preview_destroy */
static void _preview_destroy(Preview * preview)
{
if(preview->source != 0)
g_source_remove(preview->source);
free(preview->path);
object_delete(preview);
}
/**
* Place a random object at (x, y).
* \param c current chunk
* \param y
* \param x co-ordinates
* \param level generation depth
* \param good is it a good object?
* \param great is it a great object?
* \param origin item origin
* \param tval specified tval, if any
*/
void place_object(struct chunk *c, int y, int x, int level, bool good, bool great, byte origin, int tval)
{
s32b rating = 0;
struct object *new_obj;
assert(square_in_bounds(c, y, x));
if (!square_canputitem(c, y, x)) return;
new_obj = make_object(c, level, good, great, FALSE, &rating, tval);
if (!new_obj) return;
new_obj->origin = origin;
new_obj->origin_depth = c->depth;
/* Give it to the floor */
if (!floor_carry(c, y, x, new_obj, FALSE)) {
if (new_obj->artifact)
new_obj->artifact->created = FALSE;
object_delete(&new_obj);
return;
} else {
if (new_obj->artifact)
c->good_item = TRUE;
if (rating > 2500000)
rating = 2500000; /* avoid overflows */
c->obj_rating += (rating / 100) * (rating / 100);
}
}
struct lispobj *subr_minus(struct lispobj *args)
{
if(length(args) == 0)
return ERROR_ARGS;
struct lispobj *num;
char num_value[30];
snprintf(num_value, 30, "%d", NUMBER_VALUE(CAR(args)));
num = NEW_NUMBER(num_value);
args = CDR(args);
if(args == NULL) {
NUMBER_VALUE(num) = 0 - NUMBER_VALUE(num);
} else {
while(args != NULL) {
if(CAR(args) != NULL && OBJ_TYPE(CAR(args)) == NUMBER) {
NUMBER_VALUE(num) -= NUMBER_VALUE(CAR(args));
args = CDR(args);
} else {
object_delete(num);
return NEW_ERROR("Argument is not a number.\n");
}
}
}
return num;
}
/* calendar_event_delete */
void calendarevent_delete(CalendarEvent * event)
{
free(event->name);
free(event->location);
free(event->description);
object_delete(event);
}
/* video_destroy */
static void _video_destroy(VideoPhonePlugin * video)
{
size_t i;
_video_stop(video);
if(video->channel != NULL)
{
/* XXX we ignore errors at this point */
g_io_channel_shutdown(video->channel, TRUE, NULL);
g_io_channel_unref(video->channel);
}
#if !GTK_CHECK_VERSION(3, 0, 0)
if(video->pixmap != NULL)
g_object_unref(video->pixmap);
if(video->gc != NULL)
g_object_unref(video->gc);
#endif
if(video->window != NULL)
gtk_widget_destroy(video->window);
if(video->fd >= 0)
close(video->fd);
if((char *)video->rgb_buffer != video->raw_buffer)
free(video->rgb_buffer);
for(i = 0; i < video->buffers_cnt; i++)
if(video->buffers[i].start != MAP_FAILED)
munmap(video->buffers[i].start,
video->buffers[i].length);
free(video->buffers);
free(video->raw_buffer);
string_delete(video->device);
object_delete(video);
}
void vfs_node_purge_contents(struct vfs_inode *node) {
struct volume_object object;
struct vfs_inode_ptr last_ptr;
uint64_t max_chunk;
object.index = node->data.ino;
object.chunk = 0;
if (S_ISDIR(node->data.mode)) {
if (vfs_dir_read(node->data.ino, NULL, &last_ptr) != 0) {
warning("File system missing data at inode %016" PRIx64,
node->data.ino);
return;
}
max_chunk = last_ptr.object.chunk;
} else {
max_chunk = node->data.last_block >> OBJECT_MAX_SIZE_LOG2;
}
while (object.chunk <= max_chunk) {
if (object_delete(object) != SUCCESS) {
warning("Delete error on inode %016" PRIx64, object.index);
break;
}
object.chunk++;
}
}
/* notes_delete */
void notes_delete(Notes * notes)
{
notes_note_save_all(notes);
notes_note_remove_all(notes);
free(notes);
object_delete(notes);
}
/* openmoko_destroy */
static void _openmoko_destroy(Openmoko * openmoko)
{
_openmoko_mixer_close(openmoko);
if(openmoko->window != NULL)
gtk_widget_destroy(openmoko->window);
object_delete(openmoko);
}
/* dex_destroy */
static void _dex_destroy(AsmFormatPlugin * format)
{
Dex * dex = format;
free(dex->dmii);
object_delete(dex);
}
/* playerbackend_destroy */
void playerbackend_destroy(PlayerBackend * player)
{
char const cmd[] = "\nquit\n";
gsize written;
size_t i;
int status = 0;
pid_t res;
struct timespec ts = { 0, 500000 };
if(player->read_id != 0)
g_source_remove(player->read_id);
if(player->write_id != 0)
g_source_remove(player->write_id);
if(player->timeout_id != 0)
g_source_remove(player->timeout_id);
g_io_channel_write_chars(player->channel[1], cmd, sizeof(cmd) - 1,
&written, NULL);
g_io_channel_shutdown(player->channel[1], FALSE, NULL);
for(i = 0; i < 6; i++)
{
if((res = waitpid(player->pid, &status, WNOHANG)) == -1)
{
player_error(NULL, "waitpid", 0);
break;
}
else if(res == 0)
nanosleep(&ts, NULL);
else if(WIFEXITED(status) || WIFSIGNALED(status))
break;
if(i == 4)
kill(player->pid, SIGTERM);
}
object_delete(player);
}
static void saImmOmLongDn_03(void) {
SaImmHandleT immHandle;
SaImmAdminOwnerHandleT ownerHandle;
SaImmCcbHandleT ccbHandle;
SaAisErrorT rc;
SaNameT dn;
const SaImmAdminOwnerNameT ownerName = (const SaImmAdminOwnerNameT)__FUNCTION__;
SaImmAttrValueT rdnVal[1] = { (SaImmAttrValueT)&dn };
SaImmAttrValuesT_2 attrValue = { "rdn", SA_IMM_ATTR_SANAMET, 1, rdnVal };
const SaImmAttrValuesT_2 *attrValues[2] = { &attrValue, NULL };
safassert(saImmOmInitialize(&immHandle, NULL, &immVersion), SA_AIS_OK);
config_class_create(immHandle);
osaf_extended_name_lend(longDn, &dn);
safassert(saImmOmAdminOwnerInitialize(immHandle, ownerName, SA_TRUE, &ownerHandle), SA_AIS_OK);
safassert(saImmOmCcbInitialize(ownerHandle, 0, &ccbHandle), SA_AIS_OK);
rc = saImmOmCcbObjectCreate_2(ccbHandle, configClassName, NULL, attrValues);
saImmOmCcbApply(ccbHandle);
safassert(saImmOmCcbFinalize(ccbHandle), SA_AIS_OK);
safassert(object_delete(ownerHandle, &dn, 1), SA_AIS_OK);
config_class_delete(immHandle);
safassert(saImmOmAdminOwnerFinalize(ownerHandle), SA_AIS_OK);
safassert(saImmOmFinalize(immHandle), SA_AIS_OK);
test_validate(rc, SA_AIS_OK);
}
static void symbol_table_delete(struct lispobj *symbol)
{
struct lispobj *tmp_symt, *prev_cons;
tmp_symt = symbol_table;
prev_cons = NULL;
/* Try to find the necessary symbol in the symbol table. */
while(tmp_symt != NULL) {
struct lispobj *curs = CAR(tmp_symt);
/* If have found it delete it. */
if(curs == symbol) {
if(prev_cons != NULL) {
CDR(prev_cons) = CDR(tmp_symt);
} else {
symbol_table = CDR(tmp_symt);
}
CAR(tmp_symt) = NULL;
CDR(tmp_symt) = NULL;
object_delete(tmp_symt);
return;
}
prev_cons = tmp_symt;
tmp_symt = CDR(tmp_symt);
}
return;
}
/* engineering_destroy */
static void _engineering_destroy(Engineering * engineering)
{
if(engineering->source != 0)
g_source_remove(engineering->source);
gtk_widget_destroy(engineering->window);
object_delete(engineering);
}
int rdis_remove_function (struct _rdis * rdis, uint64_t address)
{
map_remove(rdis->functions, address);
map_remove(rdis->labels, address);
struct _graph * family = graph_family(rdis->graph, address);
if (family == NULL)
return -1;
struct _graph_it * it;
for (it = graph_iterator(family); it != NULL; it = graph_it_next(it)) {
struct _graph_node * node = graph_it_node(it);
printf("rdis_remove_function %p %p %p %llx\n",
node,
node->data,
node->edges,
(unsigned long long) node->index);
graph_remove_node(rdis->graph, node->index);
}
object_delete(family);
rdis_callback(rdis, RDIS_CALLBACK_GRAPH
| RDIS_CALLBACK_FUNCTION
| RDIS_CALLBACK_LABEL);
return 0;
}
/**
* Place a random object at (x, y).
* \param c current chunk
* \param y co-ordinates
* \param x co-ordinates
* \param level generation depth
* \param good is it a good object?
* \param great is it a great object?
* \param origin item origin
* \param tval specified tval, if any
*/
void place_object(struct chunk *c, int y, int x, int level, bool good,
bool great, byte origin, int tval)
{
s32b rating = 0;
struct object *new_obj;
bool dummy = true;
if (!square_in_bounds(c, y, x)) return;
if (!square_canputitem(c, y, x)) return;
/* Make an appropriate object */
new_obj = make_object(c, level, good, great, false, &rating, tval);
if (!new_obj) return;
new_obj->origin = origin;
new_obj->origin_depth = c->depth;
/* Give it to the floor */
if (!floor_carry(c, y, x, new_obj, &dummy)) {
if (new_obj->artifact) {
new_obj->artifact->created = false;
}
object_delete(&new_obj);
return;
} else {
list_object(c, new_obj);
if (new_obj->artifact) {
c->good_item = true;
}
/* Avoid overflows */
if (rating > 2500000) {
rating = 2500000;
}
c->obj_rating += (rating / 100) * (rating / 100);
}
}
void coind_error(YAAMP_COIND *coind, const char *s)
{
coind->auto_ready = false;
object_delete(coind);
debuglog("%s error %s\n", coind->name, s);
}
/* desktop_widget_delete */
void desktop_widget_delete(DesktopWidget * widget)
{
if(widget->definition != NULL && widget->dplugin != NULL)
widget->definition->destroy(widget->dplugin);
if(widget->plugin != NULL)
plugin_delete(widget->plugin);
object_delete(widget);
}
/* note_delete */
void note_delete(Note * note)
{
string_delete(note->description);
free(note->filename);
if(note->config != NULL)
config_delete(note->config);
object_delete(note);
}
/* camera_destroy */
static void _camera_destroy(CameraWidget * camera)
{
if(camera->camera != NULL)
camera_delete(camera->camera);
if(camera->window)
gtk_widget_destroy(camera->window);
object_delete(camera);
}
/* directory_delete */
void directory_delete(Directory * directory)
{
if(directory->config != NULL)
config_delete(directory->config);
if(directory->appserver != NULL)
appserver_delete(directory->appserver);
object_delete(directory);
}
/* arch_delete */
void arch_delete(AsmArch * arch)
{
#ifdef DEBUG
fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
plugin_delete(arch->handle);
object_delete(arch);
}
/**
* Let the floor carry an object, deleting old ignored items if necessary.
* The calling function must deal with the dropped object on failure.
*
* Optionally put the object at the top or bottom of the pile
*/
bool floor_carry(struct chunk *c, int y, int x, struct object *drop, bool last)
{
int n = 0;
struct object *obj, *ignore = floor_get_oldest_ignored(y, x);
/* Fail if the square can't hold objects */
if (!square_isobjectholding(c, y, x))
return false;
/* Scan objects in that grid for combination */
for (obj = square_object(c, y, x); obj; obj = obj->next) {
/* Check for combination */
if (object_similar(obj, drop, OSTACK_FLOOR)) {
/* Combine the items */
object_absorb(obj, drop);
/* Result */
return true;
}
/* Count objects */
n++;
}
/* The stack is already too large */
if (n >= z_info->floor_size || (!OPT(player, birth_stacking) && n)) {
/* Delete the oldest ignored object */
if (ignore) {
square_excise_object(c, y, x, ignore);
delist_object(c, ignore);
object_delete(&ignore);
} else
return false;
}
/* Location */
drop->iy = y;
drop->ix = x;
/* Forget monster */
drop->held_m_idx = 0;
/* Link to the first or last object in the pile */
if (last)
pile_insert_end(&c->squares[y][x].obj, drop);
else
pile_insert(&c->squares[y][x].obj, drop);
/* Record in the level list */
list_object(c, drop);
/* Redraw */
square_note_spot(c, y, x);
square_light_spot(c, y, x);
/* Result */
return true;
}
/*
* In this pass, we are fixing the edges from jmp-like instructions and their
* targets
*/
void x8664_graph_1 (struct _graph * graph,
uint64_t address)
{
struct _graph_it * it;
ud_t ud_obj;
for (it = graph_iterator(graph); it != NULL; it = graph_it_next(it)) {
struct _list * ins_list = graph_it_data(it);
struct _ins * ins = list_first(ins_list);
ud_init (&ud_obj);
ud_set_mode (&ud_obj, 64);
ud_set_input_buffer(&ud_obj, ins->bytes, ins->size);
ud_disassemble(&ud_obj);
struct ud_operand * operand;
switch (ud_obj.mnemonic) {
case UD_Ijmp :
case UD_Ijo :
case UD_Ijno :
case UD_Ijb :
case UD_Ijae :
case UD_Ijz :
case UD_Ijnz :
case UD_Ijbe :
case UD_Ija :
case UD_Ijs :
case UD_Ijns :
case UD_Ijp :
case UD_Ijnp :
case UD_Ijl :
case UD_Ijge :
case UD_Ijle :
case UD_Ijg :
operand = &(ud_obj.operand[0]);
if (operand->type != UD_OP_JIMM)
break;
uint64_t head = graph_it_index(it);
uint64_t tail = head
+ ud_insn_len(&ud_obj)
+ udis86_sign_extend_lval(operand);
int type = INS_EDGE_JCC_TRUE;
if (ud_obj.mnemonic == UD_Ijmp)
type = INS_EDGE_JUMP;
struct _ins_edge * ins_edge = ins_edge_create(type);
graph_add_edge(graph, head, tail, ins_edge);
object_delete(ins_edge);
break;
default :
break;
}
}
}