bool M2MServer::is_resource_present(ServerResource resource) const
{
bool success = false;
M2MResource *res = get_resource(resource);
if(res) {
success = true;
}
return success;
}
std::string XMLResourceDocument::get_string_resource(
const std::string &resource_id,
const std::string &default_value) const
{
if (!resource_exists(resource_id))
return default_value;
XMLResourceNode resource = get_resource(resource_id);
return resource.get_element().get_attribute("value");
}
HTTP_HEADER *
copy_source_header(const char *path)
{
HTTP_HEADER *h = g_new0(HTTP_HEADER, 1);
h->key = strdup("x-amz-copy-source");
h->value = get_resource(path);
return h;
}
bool M2MServer::set_resource_value(ServerResource resource,
const String &value)
{
bool success = false;
M2MResource* res = get_resource(resource);
if(res && (M2MServer::Binding == resource)) {
success = res->set_value((const uint8_t*)value.c_str(),(uint32_t)value.length());
}
return success;
}
void MPILock::release(Resource resource) {
MPIResource *res = get_resource(resource);
res->lock();
if (DEBUG) printf("#%u: release(%s)\n", index, RESOURCE(resource));
if (DEBUG) res->print_state(sides);
res->change_state(IDLE);
deliver_token(res);
if (DEBUG) res->print_state(sides);
res->unlock();
}
int CL_ResourceManager::get_integer_resource(
const CL_String &resource_id,
int default_value)
{
if (!resource_exists(resource_id))
return default_value;
CL_Resource resource = get_resource(resource_id);
return CL_StringHelp::text_to_int(resource.get_element().get_attribute("value"));
}
CL_String CL_ResourceManager::get_string_resource(
const CL_String &resource_id,
const CL_StringRef &default_value)
{
if (!resource_exists(resource_id))
return default_value;
CL_Resource resource = get_resource(resource_id);
return resource.get_element().get_attribute("value");
}
int XMLResourceDocument::get_integer_resource(
const std::string &resource_id,
int default_value) const
{
if (!resource_exists(resource_id))
return default_value;
XMLResourceNode resource = get_resource(resource_id);
return StringHelp::text_to_int(resource.get_element().get_attribute("value"));
}
const char *
get_message(const char *key)
{
char *r;
if ((r = get_resource(lazyaf("%s.%s", ResMessage, key))) != NULL) {
return r;
} else {
return lazyaf("[missing \"%s\" message]", key);
}
}
void onWebsocketOpen(wspp::connection_hdl hdl)
{
auto connection = m_wsserver.get_con_from_hdl(hdl);
string uuid = connection->get_resource().substr(23);
//m_websocketServer.send(hdl, "5::{name:'connect', args={}}", ws::frame::opcode::value::text);
m_wsserver.send(hdl, "1::", wspp::frame::opcode::value::text);
// m_websocketServer.set_timer(10*1000, bind(&SocketIoServer::sendHeartbeart, this, hdl));
// m_websocketServer.set_timer(1*1000, bind(&SocketIoServer::customEvent, this, hdl));
}
bool M2MSecurity::set_resource_value(SecurityResource resource,
const String &value)
{
bool success = false;
if(M2MSecurity::M2MServerUri == resource) {
M2MResource* res = get_resource(resource);
if(res) {
success = res->set_value((const uint8_t*)value.c_str(),(uint32_t)value.length());
}
}
return success;
}
uint32_t M2MFirmware::resource_value_buffer(FirmwareResource resource,
uint8_t *&data) const
{
uint32_t size = 0;
M2MResource* res = get_resource(resource);
if(res) {
if(M2MFirmware::Package == resource) {
res->get_value(data,size);
}
}
return size;
}
bool M2MFirmware::set_resource_value(FirmwareResource resource,
const uint8_t *value,
const uint32_t length)
{
bool success = false;
M2MResource* res = get_resource(resource);
if(res) {
if(M2MFirmware::Package == resource) {
success = res->set_value(value,length);
}
}
return success;
}
void image_loadRes(img_t *img,int id)
{
int sz;
HGLOBAL myResourceData;
get_resource(id,&myResourceData,&sz);
if(!sz)
{
log_err("ERROR in image_loadRes(): failed get_resource\n");
return;
}
image_load(img,myResourceData,sz);
}
int mgr_get_resource(struct rsc_mgr *mgr, unsigned int n, unsigned int *ridx)
{
int err;
if (n > mgr->avail)
return -ENOENT;
err = get_resource(mgr->rscs, mgr->amount, n, ridx);
if (!err)
mgr->avail -= n;
return err;
}
static void game_init(game_t *p_game)
{
void *p_buf;
memset(p_game, 0, sizeof(game_t));
if ( !(p_buf = (void *)get_resource(SPRITE_FRAMES, SPRITE_FRAMES_SIZE)) )
error_msg("Alloc space for sprite frames\n");
p_game->pp_sprites = unpack_sprite_frames(p_buf, SPRITE_FRAMES_UNPACKED_SIZE, N_FRAMES);
vDisposePtr(p_buf);
p_game->p_tiles = BG_TILES;
p_game->player.sprite.dir = RIGHT;
sprite_set_state(&p_game->player.sprite, SPRITE_IDLE);
p_game->player.sprite.offset_right = FRAME_BRUCE_FIRST_RIGHT;
p_game->player.sprite.p_bounds = bruce_bounding;
p_game->player.sprite.p_anims = bruce_anims;
if ( !(p_buf = get_resource(BRUCE_MIDI, BRUCE_MIDI_SIZE)) )
error_msg("Alloc space for midi file failed!\n");
if ( !(p_game->p_midi_data = unpack_data(p_buf, BRUCE_MIDI_UNPACKED_SIZE)) )
error_msg("Unpack midi failed!\n");
vDisposePtr(p_buf);
store_midifile("bruce.mid", p_game->p_midi_data, BRUCE_MIDI_UNPACKED_SIZE);
vDisposePtr(p_game->p_midi_data);
play_midifile("bruce.mid");
if ( !(p_buf = (void *)get_resource(TITLE_SCREEN, TITLE_SCREEN_SIZE)) )
error_msg("Alloc space for sprite frames\n");
if ( !(p_game->p_title_screen = (SPRITE*)unpack_data(p_buf, TITLE_SCREEN_UNPACKED_SIZE)) )
error_msg("Unpack title screen failed!\n");
vDisposePtr(p_buf);
}
uint32_t M2MSecurity::resource_value_buffer(SecurityResource resource,
uint8_t *&data) const
{
uint32_t size = 0;
M2MResource* res = get_resource(resource);
if(res) {
if(M2MSecurity::PublicKey == resource ||
M2MSecurity::ServerPublicKey == resource ||
M2MSecurity::Secretkey == resource) {
res->get_value(data,size);
}
}
return size;
}
/* A version of get_resource that accepts sprintf arguments. */
char *
get_fresource(const char *fmt, ...)
{
va_list args;
char *name;
char *r;
va_start(args, fmt);
name = xs_vbuffer(fmt, args);
va_end(args);
r = get_resource(name);
Free(name);
return r;
}
String M2MFirmware::resource_value_string(FirmwareResource resource) const
{
String value = "";
M2MResource* res = get_resource(resource);
if(res) {
if(M2MFirmware::PackageUri == resource ||
M2MFirmware::PackageName == resource ||
M2MFirmware::PackageVersion == resource) {
value = res->get_value_string();
}
}
return value;
}
int64_t M2MFirmware::resource_value_int(FirmwareResource resource) const
{
int64_t value = -1;
M2MResource* res = get_resource(resource);
if(res) {
if(M2MFirmware::State == resource ||
M2MFirmware::UpdateSupportedObjects == resource ||
M2MFirmware::UpdateResult == resource) {
value = res->get_value_int();
}
}
return value;
}
struct resource_struct *create_ftp_server_resource(struct workspace_object_struct *parent_object, char *name, char *address, unsigned char security)
{
struct resource_struct *network_resource=parent_object->resource;
struct resource_struct *resource=NULL;
struct net_ftp_server_struct *ftpserver=NULL;
resource=get_resource();
if (!resource) goto out;
ftpserver=malloc(sizeof(struct net_ftp_server_struct));
if ( ! ftpserver ) {
free(resource);
resource=NULL;
goto out;
}
resource->parent=network_resource;
resource->group=RESOURCE_GROUP_FTP;
resource->type=FTP_TYPE_SERVER;
resource->security=security;
resource->primary=1;
resource->data=(void *) ftpserver;
ftpserver->detect_time.tv_sec=0;
ftpserver->detect_time.tv_nsec=0;
ftpserver->refresh_time.tv_sec=0;
ftpserver->refresh_time.tv_nsec=0;
/* server name, address and type (public or private) */
strcpy(ftpserver->name, name);
strcpy(ftpserver->address, address);
/* the other way around compared to resource read from cache */
add_resource_to_list(resource, &ftp_resource_list);
out:
return resource;
}
bool M2MSecurity::set_resource_value(SecurityResource resource,
const uint8_t *value,
const uint16_t length)
{
bool success = false;
M2MResource* res = get_resource(resource);
if(res) {
if(M2MSecurity::PublicKey == resource ||
M2MSecurity::ServerPublicKey == resource ||
M2MSecurity::Secretkey == resource) {
success = res->set_value(value,length);
}
}
return success;
}
void MPILock::receive_token(unsigned sender, MPITokenMessage &message) {
MPIResource *resource = get_resource(message.resource);
resource->lock();
if (DEBUG) printf("#%u: received token from #%u for %s\n", index, sender, RESOURCE(message.resource));
if (DEBUG) resource->print_state(sides);
resource->add_token(SIDE_INDEX_SELF);
if (message.send_back) {
resource->push_request(get_side_index(sender));
}
deliver_token(resource);
if (DEBUG) resource->print_state(sides);
resource->unlock();
}
static void handle_request (int requestfd)
{
char buffer[512];
ssize_t bytes_read;
/* Read some data from the client. */
bytes_read = read (requestfd, buffer, sizeof (buffer) - 1);
if (bytes_read > 0) {
char method[sizeof (buffer)];
char url[sizeof (buffer)];
char protocol[sizeof (buffer)];
/* Some data was read successfully. NUL-terminate the buffer so
we can use string operations on it. */
buffer[bytes_read] = '\0';
/* The first line the client sends is the HTTP request, which is
composed of a method, the requested page, and the protocol
version. */
sscanf (buffer, "%s %s %s", method, url, protocol);
printf("Received request:\n%s", buffer);
/* Check the protocol field. We understand HTTP versions 1.0 and
1.1. */
if (strcmp (protocol, "HTTP/1.0") && strcmp (protocol, "HTTP/1.1")) {
/* We don't understand this protocol. Report a bad response. */
write (requestfd, bad_request_response, strlen (bad_request_response));
}
else if (strcmp (method, "GET")) {
/* This server only implements the GET method. The client
specified some other method, so report the failure. */
char response[1024];
snprintf (response, sizeof (response), bad_method_response_template, method);
write (requestfd, response, strlen (response));
}
else
/* A valid request. Process it. */
get_resource (requestfd, url);
}
else if (bytes_read == 0)
/* The client closed the connection before sending any data.
Nothing to do. */
;
else
/* The call to read failed. */
error("ERROR reading from request");
}
const char* bwipp_get_property(BWIPP *ctx, const char *name,
const char *prop) {
const Property *property;
const Resource *resource;
resource=get_resource(ctx,name);
if (resource==NULL)
return NULL;
property=get_property(resource,prop);
if (property==NULL)
return NULL;
return property->value;
}
static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
{
struct unicorn_fh *fh = priv;
struct unicorn_dev *dev = fh->dev;
int err, res;
if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL;
if (i != fh->type)
return -EINVAL;
res = get_resource(fh, 0x01 << fh->channel);
err = videobuf_streamoff(&fh->vidq);
if (err < 0)
return err;
res_free(dev, fh, res);
return 0;
}
int change_resource(unit * u, const resource_type * rtype, int change)
{
int i = 0;
assert(rtype);
if (rtype->uchange)
i = rtype->uchange(u, rtype, change);
else if (rtype == get_resourcetype(R_AURA))
i = change_spellpoints(u, change);
else if (rtype == get_resourcetype(R_PERMAURA))
i = change_maxspellpoints(u, change);
else
assert(!"undefined resource detected. rtype->uchange not initialized.");
assert(i == get_resource(u, rtype));
assert(i >= 0);
return i;
}
static void task0(void *argpointer){
/* get task method */
int method = *((int *) argpointer);
free(argpointer);
int id = 0;
sync_threads(id);
/* get resource */
get_resource(method, id);
/* do work */
rt_printf("Task %i start\n", id);
busy_wait_ms(3);
/* release resource */
release_resource(method, id);
}
bool M2MFirmware::set_resource_value(FirmwareResource resource,
int64_t value)
{
bool success = false;
M2MResource* res = get_resource(resource);
if(res) {
if(M2MFirmware::State == resource ||
M2MFirmware::UpdateSupportedObjects == resource ||
M2MFirmware::UpdateResult == resource) {
// If it is any of the above resource
// set the value of the resource.
if (check_value_range(resource, value)) {
success = res->set_value(value);
}
}
}
return success;
}
static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
{
struct unicorn_fh *fh = priv;
struct unicorn_dev *dev = fh->dev;
if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)) {
return -EINVAL;
}
if (unlikely(i != fh->type)) {
return -EINVAL;
}
if (unlikely(!res_get(dev, fh, get_resource(fh, 0x01 << fh->channel)))) {
return -EBUSY;
}
return videobuf_streamon(&fh->vidq);
}
