static jobjectArray getInputPropertiesNative(JNIEnv *env, jobject object,
jstring path) {
#ifdef HAVE_BLUETOOTH
LOGV(__FUNCTION__);
if (nat) {
DBusMessage *msg, *reply;
DBusError err;
dbus_error_init(&err);
const char *c_path = env->GetStringUTFChars(path, NULL);
reply = dbus_func_args_timeout(env,
nat->conn, -1, c_path,
"org.bluez.Input", "GetProperties",
DBUS_TYPE_INVALID);
env->ReleaseStringUTFChars(path, c_path);
if (!reply && dbus_error_is_set(&err)) {
LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, reply);
return NULL;
} else if (!reply) {
LOGV("DBus reply is NULL in function %s", __FUNCTION__);
return NULL;
}
DBusMessageIter iter;
if (dbus_message_iter_init(reply, &iter))
return parse_properties(env, &iter, (Properties *)&input_properties,
sizeof(input_properties) / sizeof(Properties));
}
#endif
return NULL;
}
static void parse_interfaces(GDBusClient *client, const char *path,
DBusMessageIter *iter)
{
DBusMessageIter dict;
if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
return;
dbus_message_iter_recurse(iter, &dict);
while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
DBusMessageIter entry;
const char *interface;
dbus_message_iter_recurse(&dict, &entry);
if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
break;
dbus_message_iter_get_basic(&entry, &interface);
dbus_message_iter_next(&entry);
parse_properties(client, path, interface, &entry);
dbus_message_iter_next(&dict);
}
}
int parse_properties(t_list **tokens)
{
t_list *save;
save = *tokens;
if (terminal(tokens, WORD) == 0)
{
(*tokens) = save;
return (0);
}
(*tokens) = (*tokens)->next;
if (terminal(tokens, COLON) == 0)
{
(*tokens) = save;
return (0);
}
(*tokens) = (*tokens)->next;
if (terminal(tokens, WORD) == 0)
{
(*tokens) = save;
return (0);
}
(*tokens) = (*tokens)->next;
if (terminal(tokens, COMMA))
{
(*tokens) = (*tokens)->next;
parse_properties(tokens);
}
return (1);
}
static int property_changed_cb(mrp_dbus_t *dbus,
mrp_dbus_msg_t *msg, /* (sa{sv}as) */
void *user_data)
{
context_t *ctx = (context_t *)user_data;
const char *sender = mrp_dbus_msg_sender(msg);
player_t *player = NULL;
const char *interface = NULL;
MRP_UNUSED(dbus);
if (!ctx || !sender)
return FALSE;
if (!(player = clients_find_player_by_address(ctx, sender)))
return FALSE;
if (mrp_dbus_msg_arg_type(msg, NULL) != MRP_DBUS_TYPE_STRING)
return FALSE;
mrp_dbus_msg_read_basic(msg, MRP_DBUS_TYPE_STRING, (void *)&interface);
if (strcmp(interface, "org.mpris.MediaPlayer2.Player"))
return FALSE;
return parse_properties(player, msg);
}
static void property_query_cb(mrp_dbus_t *dbus,
mrp_dbus_msg_t *msg,
void *user_data)
{
player_t *player = (player_t *)user_data;
MRP_UNUSED(dbus);
parse_properties(player, msg);
}
void
scanning_for_playlists_dlg::parse_output(wxString const &file_name,
wxArrayString const &output) {
uint64_t min_duration = mdlg->options.min_playlist_duration * 1000000000ull;
auto playlist = std::make_shared<playlist_file_t>(file_name, output);
// mxinfo(boost::format("------------------------------------------------------------\n"));
for (size_t idx = 0, count = output.GetCount(); idx < count; ++idx) {
auto &line = output[idx];
// mxinfo(boost::format("line: %1%\n") % to_utf8(line));
if (line.StartsWith(wxT("File"))) {
auto properties = parse_properties(line, wxT("container:"));
// mxinfo(boost::format(" FILE! num pro: %1% num fi: %2%\n") % properties.first.size() % properties.second.size());
if (!parse_number(to_utf8(properties.first[wxT("playlist_size")]), playlist->size))
playlist->size = 0;
if (!parse_number(to_utf8(properties.first[wxT("playlist_duration")]), playlist->duration))
playlist->duration = 0;
if (!parse_number(to_utf8(properties.first[wxT("playlist_chapters")]), playlist->chapters))
playlist->chapters = 0;
playlist->files = properties.second;
} else if (line.StartsWith(wxT("Track"))) {
auto properties = parse_properties(line, wxT("Track ID"));
auto type = line.AfterFirst(wxT(':')).Mid(1).BeforeFirst(wxT(' '));
playlist->tracks.push_back(playlist_file_track_t{
type == wxT("audio") ? Z("audio") : type == wxT("video") ? Z("video") : type == wxT("subtitles") ? Z("subtitles") : Z("unknown"),
line.AfterFirst(wxT('(')).BeforeFirst(wxT(')')),
properties.first[wxT("language")]
});
}
}
if (playlist->duration >= min_duration)
m_playlists.push_back(playlist);
}
/*
* process animations
*/
int parse_animation() {
int numbers[1000];
int numbers_max = 0;
char *overlay_code = NULL;
token = yylex();
if (token == OVERLAY_CODE) {
overlay_code = strduplicate(string);
token = yylex();
}
while (token == NUMBER) {
numbers[numbers_max++] = int_val;
token = yylex();
if (token == COMMA)
token = yylex();
}
if (token == SQUARE_O_BRACE) {
char *properties;
if ((properties = parse_properties()) != NULL) {
if ((token = yylex()) == VALUE) {
if (overlay_code != NULL)
fprintf(ofile,"\\only%s{\\begin{figure}\n",overlay_code);
else
fprintf(ofile,"\\begin{figure}\n");
for (int i=0;i<numbers_max;i++) {
fprintf(ofile,"\\includegraphics<%d>[%s,page=%d]{%s}\n",
i+1, properties, numbers[i], string);
}
if (overlay_code != NULL)
fprintf(ofile,"\\end{figure}}\n");
else
fprintf(ofile,"\\end{figure}\n");
free(properties);
token = yylex();
return 1;
} else {
free(properties);
fprintf(stderr,
"[%d] Figure mode: Missing image, found %s instead\n",
yylineno, get_token_name(token));
return 0;
}
} else {
return 0;
}
} else {
fprintf(stderr, "[%d] Figure mode: Missing [, found %s instead\n",
yylineno, get_token_name(token));
return 0;
}
}
//
// Initialize the CoreCLR. Creates and starts CoreCLR host and creates an app domain
//
// Parameters:
// exePath - Absolute path of the executable that invoked the ExecuteAssembly
// appDomainFriendlyName - Friendly name of the app domain that will be created to execute the assembly
// propertyCount - Number of properties (elements of the following two arguments)
// propertyKeys - Keys of properties of the app domain
// propertyValues - Values of properties of the app domain
// hostHandle - Output parameter, handle of the created host
// domainId - Output parameter, id of the created app domain
//
// Returns:
// HRESULT indicating status of the operation. S_OK if the assembly was successfully executed
//
int STDAPICALLTYPE coreclr_initialize (const char* exePath, const char* appDomainFriendlyName,
int propertyCount, const char** propertyKeys, const char** propertyValues,
void** hostHandle, unsigned int* domainId)
{
mono_runtime_register_appctx_properties (propertyCount, propertyKeys, propertyValues);
// TODO: TRUSTED_PLATFORM_ASSEMBLIES is the property key for managed assemblies mapping
if (!parse_properties (propertyCount, propertyKeys, propertyValues))
return 0x80004005; /* E_FAIL */
install_assembly_loader_hooks ();
if (native_lib_paths != NULL)
mono_set_pinvoke_search_directories (native_lib_paths->dir_count, native_lib_paths->dirs);
return 0;
}
static int parse_tile(xmlTextReaderPtr reader, tmx_tile **tile_headadr, const char *filename) {
tmx_tile *res = NULL;
int curr_depth;
const char *name;
char *value;
curr_depth = xmlTextReaderDepth(reader);
if (!(res = alloc_tile())) return 0;
while (*tile_headadr) {
tile_headadr = &((*tile_headadr)->next);
}
*tile_headadr = res;
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"id"))) { /* id */
res->id = atoi(value);
tmx_free_func(value);
}
else {
tmx_err(E_MISSEL, "xml parser: missing 'id' attribute in the 'tile' element");
return 0;
}
do {
if (xmlTextReaderRead(reader) != 1) return 0; /* error_handler has been called */
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) {
name = (char*)xmlTextReaderConstName(reader);
if (!strcmp(name, "properties")) {
if (!parse_properties(reader, &(res->properties))) return 0;
}
else if (!strcmp(name, "image")) {
if (!parse_image(reader, &(res->image), 0, filename)) return 0;
}
else {
/* Unknow element, skip its tree */
if (xmlTextReaderNext(reader) != 1) return 0;
}
}
} while (xmlTextReaderNodeType(reader) != XML_READER_TYPE_END_ELEMENT ||
xmlTextReaderDepth(reader) != curr_depth);
return 1;
}
int parse_camera(t_list **tokens)
{
t_list *save;
save = *tokens;
if (terminal(tokens, WORD) == 0 || ft_strcmp(get_token(tokens)->lexeme, "camera"))
{
(*tokens) = save;
return (0);
}
(*tokens) = (*tokens)->next;
if (terminal(tokens, OPENING_BRACKET) == 0)
return (0);
(*tokens) = (*tokens)->next;
if (parse_properties(tokens) == 0)
return (0);
if (terminal(tokens, CLOSING_BRACKET) == 0)
return (0);
(*tokens) = (*tokens)->next;
return (1);
}
int parse_shape(t_list **tokens)
{
t_list *save;
save = *tokens;
if (terminal(tokens, WORD) == 0)
{
(*tokens) = save;
return (0);
}
(*tokens) = (*tokens)->next;
if (terminal(tokens, OPENING_BRACKET) == 0)
return (0);
(*tokens) = (*tokens)->next;
if (parse_properties(tokens) == 0)
return (0);
if (terminal(tokens, CLOSING_BRACKET) == 0)
return (0);
(*tokens) = (*tokens)->next;
return (1);
}
static DBusMessage *register_endpoint(DBusConnection *conn, DBusMessage *msg,
void *data)
{
struct media_adapter *adapter = data;
DBusMessageIter args, props;
const char *sender, *path, *uuid;
gboolean delay_reporting = FALSE;
uint8_t codec;
uint8_t *capabilities;
int size = 0;
int err;
sender = dbus_message_get_sender(msg);
dbus_message_iter_init(msg, &args);
dbus_message_iter_get_basic(&args, &path);
dbus_message_iter_next(&args);
if (media_adapter_find_endpoint(adapter, sender, path, NULL) != NULL)
return btd_error_already_exists(msg);
dbus_message_iter_recurse(&args, &props);
if (dbus_message_iter_get_arg_type(&props) != DBUS_TYPE_DICT_ENTRY)
return btd_error_invalid_args(msg);
if (parse_properties(&props, &uuid, &delay_reporting, &codec,
&capabilities, &size) < 0)
return btd_error_invalid_args(msg);
if (media_endpoint_create(adapter, sender, path, uuid, delay_reporting,
codec, capabilities, size, &err) == NULL) {
if (err == -EPROTONOSUPPORT)
return btd_error_not_supported(msg);
else
return btd_error_invalid_args(msg);
}
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
/*
* process figures
*/
int parse_figure_inner(int index) {
char *overlay_code;
token = yylex();
if (token == OVERLAY_CODE) {
overlay_code = strduplicate(string);
token = yylex();
} else
overlay_code = strduplicate("");
if (token == SQUARE_O_BRACE) {
char *properties;
if ((properties = parse_properties()) != NULL) {
if ((token = yylex()) == VALUE) {
fprintf(ofile,"\\includegraphics%s[%s]{%s}\n",
overlay_code, properties, string);
free(overlay_code);
free(properties);
token = yylex();
if (token == IMAGE) // is an image group
parse_figure_inner(index+1);
return 1;
} else {
free(properties);
free(overlay_code);
fprintf(stderr,
"[%d] Figure mode: Missing image, found %s instead\n",
yylineno, get_token_name(token));
return 0;
}
} else {
free(overlay_code);
return 0;
}
} else {
free(overlay_code);
fprintf(stderr, "[%d] Figure mode: Missing [, found %s instead\n",
yylineno, get_token_name(token));
return 0;
}
}
/*
* Parse a map file into an `ALLEGRO_MAP` struct. By default, relative values of `dir`
* will be resolved relative to the path of the running executable. To change this,
* call `al_find_resources_as(RELATIVE_TO_CWD);` first.
*/
ALLEGRO_MAP *al_open_map(const char *dir, const char *filename)
{
char *cwd = al_get_current_directory();
if (!cwd) {
fprintf(stderr, "failed to get cwd; errno = %d", al_get_errno());
return NULL;
}
// `resources` will point to either cwd or the location of the running executable,
// depending on what was passed in for `rel`.
ALLEGRO_PATH *resources;
switch (resources_rel_to) {
case RELATIVE_TO_EXE:
resources = al_get_standard_path(ALLEGRO_RESOURCES_PATH);
break;
case RELATIVE_TO_CWD:
resources = al_create_path_for_directory(cwd);
break;
default:
fprintf(stderr, "unexpected value for `resources_rel_to` in al_open_map(): %d\n",
resources_rel_to);
al_free(cwd);
return NULL;
}
ALLEGRO_PATH *map_dir = al_create_path_for_directory(dir);
// Change directory to <cwd>/dir if dir is relative, otherwise dir.
ALLEGRO_PATH *new_path = (al_join_paths(resources, map_dir) ? resources : map_dir);
const char *new_path_cstr = al_path_cstr(new_path, ALLEGRO_NATIVE_PATH_SEP);
if (!al_change_directory(new_path_cstr)) {
fprintf(stderr, "Error: failed to cd into `%s` in al_open_map().\n",
new_path_cstr);
al_destroy_path(resources);
al_destroy_path(map_dir);
al_free(cwd);
return NULL;
}
al_destroy_path(resources);
al_destroy_path(map_dir);
// Read in the data file
xmlDoc *doc = xmlReadFile(filename, NULL, 0);
if (!doc) {
fprintf(stderr, "Error: failed to parse map data: %s\n", filename);
al_free(cwd);
return NULL;
}
// Get the root element, <map>
xmlNode *root = xmlDocGetRootElement(doc);
// Get some basic info
ALLEGRO_MAP *map = MALLOC(ALLEGRO_MAP);
map->width = atoi(get_xml_attribute(root, "width"));
map->height = atoi(get_xml_attribute(root, "height"));
map->tile_width = atoi(get_xml_attribute(root, "tilewidth"));
map->tile_height = atoi(get_xml_attribute(root, "tileheight"));
map->orientation = g_strdup(get_xml_attribute(root, "orientation"));
map->tile_layer_count = 0;
map->object_layer_count = 0;
// Get the tilesets
GSList *tilesets = get_children_for_name(root, "tileset");
map->tilesets = NULL;
GSList *tileset_item = tilesets;
while (tileset_item) {
xmlNode *tileset_node = (xmlNode*)tileset_item->data;
tileset_item = g_slist_next(tileset_item);
ALLEGRO_MAP_TILESET *tileset = MALLOC(ALLEGRO_MAP_TILESET);
tileset->firstgid = atoi(get_xml_attribute(tileset_node, "firstgid"));
tileset->tilewidth = atoi(get_xml_attribute(tileset_node, "tilewidth"));
tileset->tileheight = atoi(get_xml_attribute(tileset_node, "tileheight"));
tileset->name = g_strdup(get_xml_attribute(tileset_node, "name"));
// Get this tileset's image
xmlNode *image_node = get_first_child_for_name(tileset_node, "image");
tileset->width = atoi(get_xml_attribute(image_node, "width"));
tileset->height = atoi(get_xml_attribute(image_node, "height"));
tileset->source = g_strdup(get_xml_attribute(image_node, "source"));
tileset->bitmap = al_load_bitmap(tileset->source);
if (!tileset->bitmap) {
fprintf(stderr, "Error: no bitmap available; did you load the image addon?\n");
}
// Get this tileset's tiles
GSList *tiles = get_children_for_name(tileset_node, "tile");
tileset->tiles = NULL;
GSList *tile_item = tiles;
while (tile_item) {
xmlNode *tile_node = (xmlNode*)tile_item->data;
tile_item = g_slist_next(tile_item);
ALLEGRO_MAP_TILE *tile = MALLOC(ALLEGRO_MAP_TILE);
tile->id = tileset->firstgid + atoi(get_xml_attribute(tile_node, "id"));
tile->tileset = tileset;
tile->bitmap = NULL;
// Get this tile's properties
tile->properties = parse_properties(tile_node);
// TODO: add a destructor
tileset->tiles = g_slist_prepend(tileset->tiles, tile);
}
g_slist_free(tiles);
//tileset->tiles = g_slist_reverse(tileset->tiles);
// TODO: add a destructor
map->tilesets = g_slist_prepend(map->tilesets, tileset);
}
g_slist_free(tilesets);
//map->tilesets = g_slist_reverse(map->tilesets);
// Create the map's master list of tiles
cache_tile_list(map);
// Get the layers
GSList *layers = get_children_for_either_name(root, "layer", "objectgroup");
map->layers = NULL;
GSList *layer_item = layers;
while (layer_item) {
xmlNode *layer_node = (xmlNode*)layer_item->data;
layer_item = g_slist_next(layer_item);
ALLEGRO_MAP_LAYER *layer = MALLOC(ALLEGRO_MAP_LAYER);
layer->name = g_strdup(get_xml_attribute(layer_node, "name"));
layer->properties = parse_properties(layer_node);
char *layer_visible = get_xml_attribute(layer_node, "visible");
layer->visible = (layer_visible != NULL ? atoi(layer_visible) : 1);
char *layer_opacity = get_xml_attribute(layer_node, "opacity");
layer->opacity = (layer_opacity != NULL ? atof(layer_opacity) : 1.0);
if (!strcmp((const char*)layer_node->name, "layer")) {
layer->type = TILE_LAYER;
layer->width = atoi(get_xml_attribute(layer_node, "width"));
layer->height = atoi(get_xml_attribute(layer_node, "height"));
decode_layer_data(get_first_child_for_name(layer_node, "data"), layer);
// Create any missing tile objects
unsigned i, j;
for (i = 0; i < layer->height; i++) {
for (j = 0; j < layer->width; j++) {
char id = al_get_single_tile_id(layer, j, i);
if (id == 0) {
continue;
}
ALLEGRO_MAP_TILE *tile = al_get_tile_for_id(map, id);
if (!tile) {
// wasn't defined in the map file, presumably because it had no properties
tile = MALLOC(ALLEGRO_MAP_TILE);
tile->id = id;
tile->properties = g_hash_table_new(NULL, NULL);
tile->tileset = NULL;
tile->bitmap = NULL;
// locate its tilemap
GSList *tilesets = map->tilesets;
ALLEGRO_MAP_TILESET *tileset_ref;
while (tilesets) {
ALLEGRO_MAP_TILESET *tileset = (ALLEGRO_MAP_TILESET*)tilesets->data;
tilesets = g_slist_next(tilesets);
if (tileset->firstgid <= id) {
if (!tile->tileset || tileset->firstgid > tile->tileset->firstgid) {
tileset_ref = tileset;
}
}
}
tile->tileset = tileset_ref;
tileset_ref->tiles = g_slist_prepend(tileset_ref->tiles, tile);
g_hash_table_insert(map->tiles, GINT_TO_POINTER(tile->id), tile);
}
// create this tile's bitmap if it hasn't been yet
if (!tile->bitmap) {
ALLEGRO_MAP_TILESET *tileset = tile->tileset;
int id = tile->id - tileset->firstgid;
int width = tileset->width / tileset->tilewidth;
int x = (id % width) * tileset->tilewidth;
int y = (id / width) * tileset->tileheight;
if (tileset->bitmap) {
tile->bitmap = al_create_sub_bitmap(
tileset->bitmap,
x, y,
tileset->tilewidth,
tileset->tileheight);
}
}
}
}
map->tile_layer_count++;
map->tile_layers = g_slist_prepend(map->tile_layers, layer);
} else if (!strcmp((const char*)layer_node->name, "objectgroup")) {
layer->type = OBJECT_LAYER;
layer->objects = NULL;
layer->object_count = 0;
// TODO: color?
GSList *objects = get_children_for_name(layer_node, "object");
GSList *object_item = objects;
while (object_item) {
xmlNode *object_node = (xmlNode*)object_item->data;
object_item = g_slist_next(object_item);
ALLEGRO_MAP_OBJECT *object = MALLOC(ALLEGRO_MAP_OBJECT);
object->layer = layer;
object->name = g_strdup(get_xml_attribute(object_node, "name"));
object->type = g_strdup(get_xml_attribute(object_node, "type"));
object->x = atoi(get_xml_attribute(object_node, "x"));
object->y = atoi(get_xml_attribute(object_node, "y"));
object->bitmap = NULL;
char *object_width = get_xml_attribute(object_node, "width");
object->width = (object_width ? atoi(object_width) : 0);
char *object_height = get_xml_attribute(object_node, "height");
object->height = (object_height ? atoi(object_height) : 0);
char *gid = get_xml_attribute(object_node, "gid");
object->gid = (gid ? atoi(gid) : 0);
char *object_visible = get_xml_attribute(object_node, "visible");
object->visible = (object_visible ? atoi(object_visible) : 1);
// Get the object's properties
object->properties = parse_properties(object_node);
layer->objects = g_slist_prepend(layer->objects, object);
layer->object_count++;
}
map->object_layer_count++;
map->object_layers = g_slist_prepend(map->object_layers, layer);
} else {
fprintf(stderr, "Error: found invalid layer node \"%s\"\n", layer_node->name);
continue;
}
map->layers = g_slist_prepend(map->layers, layer);
}
g_slist_free(layers);
// If any objects have a tile gid, cache their image
layer_item = map->layers;
while (layer_item) {
ALLEGRO_MAP_LAYER *layer = (ALLEGRO_MAP_LAYER*)layer_item->data;
layer_item = g_slist_next(layer_item);
if (layer->type != OBJECT_LAYER) {
continue;
}
GSList *objects = layer->objects;
while (objects) {
ALLEGRO_MAP_OBJECT *object = (ALLEGRO_MAP_OBJECT*)objects->data;
objects = g_slist_next(objects);
if (!object->gid) {
continue;
}
object->bitmap = al_get_tile_for_id(map, object->gid)->bitmap;
object->width = map->tile_width;
object->height = map->tile_height;
}
}
xmlFreeDoc(doc);
al_change_directory(cwd);
al_free(cwd);
return map;
}
jobjectArray parse_remote_characteristic_properties(JNIEnv *env, DBusMessageIter *iter) {
return parse_properties(env, iter, (Properties *) &characteristic_properties,
sizeof(characteristic_properties) / sizeof(Properties));
}
jobjectArray parse_remote_service_properties(JNIEnv *env, DBusMessageIter *iter) {
return parse_properties(env, iter, (Properties *) &service_properties,
sizeof(service_properties) / sizeof(Properties));
}
static tmx_map *parse_root_map(xmlTextReaderPtr reader, const char *filename) {
tmx_map *res = NULL;
int curr_depth;
const char *name;
char *value;
name = (char*) xmlTextReaderConstName(reader);
curr_depth = xmlTextReaderDepth(reader);
if (strcmp(name, "map")) {
tmx_err(E_XDATA, "xml parser: root is not a 'map' element");
return NULL;
}
if (!(res = alloc_map())) return NULL;
/* parses each attribute */
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"orientation"))) { /* orientation */
if (res->orient = parse_orient(value), res->orient == O_NONE) {
tmx_err(E_XDATA, "xml parser: unsupported 'orientation' '%s'", value);
goto cleanup;
}
tmx_free_func(value);
} else {
tmx_err(E_MISSEL, "xml parser: missing 'orientation' attribute in the 'map' element");
goto cleanup;
}
value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"renderorder"); /* renderorder */
if (res->renderorder = parse_renderorder(value), res->renderorder == R_NONE) {
tmx_err(E_XDATA, "xml parser: unsupported 'renderorder' '%s'", value);
goto cleanup;
}
tmx_free_func(value);
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"height"))) { /* height */
res->height = atoi(value);
tmx_free_func(value);
} else {
tmx_err(E_MISSEL, "xml parser: missing 'height' attribute in the 'map' element");
goto cleanup;
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"width"))) { /* width */
res->width = atoi(value);
tmx_free_func(value);
} else {
tmx_err(E_MISSEL, "xml parser: missing 'width' attribute in the 'map' element");
goto cleanup;
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"tileheight"))) { /* tileheight */
res->tile_height = atoi(value);
tmx_free_func(value);
} else {
tmx_err(E_MISSEL, "xml parser: missing 'tileheight' attribute in the 'map' element");
goto cleanup;
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"tilewidth"))) { /* tilewidth */
res->tile_width = atoi(value);
tmx_free_func(value);
} else {
tmx_err(E_MISSEL, "xml parser: missing 'tilewidth' attribute in the 'map' element");
goto cleanup;
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"backgroundcolor"))) { /* backgroundcolor */
res->backgroundcolor = get_color_rgb(value);
tmx_free_func(value);
}
/* Parse each child */
do {
if (xmlTextReaderRead(reader) != 1) goto cleanup; /* error_handler has been called */
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) {
name = (char*)xmlTextReaderConstName(reader);
if (!strcmp(name, "tileset")) {
if (!parse_tileset(reader, &(res->ts_head), filename)) goto cleanup;
} else if (!strcmp(name, "layer")) {
if (!parse_layer(reader, &(res->ly_head), res->height, res->width, L_LAYER, filename)) goto cleanup;
} else if (!strcmp(name, "objectgroup")) {
if (!parse_layer(reader, &(res->ly_head), res->height, res->width, L_OBJGR, filename)) goto cleanup;
} else if (!strcmp(name, "imagelayer")) {
if (!parse_layer(reader, &(res->ly_head), res->height, res->width, L_IMAGE, filename)) goto cleanup;
} else if (!strcmp(name, "properties")) {
if (!parse_properties(reader, &(res->properties))) goto cleanup;
} else {
/* Unknow element, skip its tree */
if (xmlTextReaderNext(reader) != 1) goto cleanup;
}
}
} while (xmlTextReaderNodeType(reader) != XML_READER_TYPE_END_ELEMENT ||
xmlTextReaderDepth(reader) != curr_depth);
return res;
cleanup:
tmx_map_free(res);
return NULL;
}
/* parses a tileset within the tmx file or in a dedicated tsx file */
static int parse_tileset_sub(xmlTextReaderPtr reader, tmx_tileset *ts_addr, const char *filename) {
int curr_depth;
const char *name;
char *value;
curr_depth = xmlTextReaderDepth(reader);
/* parses each attribute */
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"name"))) { /* name */
ts_addr->name = value;
} else {
tmx_err(E_MISSEL, "xml parser: missing 'name' attribute in the 'tileset' element");
return 0;
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"tilewidth"))) { /* tile_width */
ts_addr->tile_width = atoi(value);
tmx_free_func(value);
} else {
tmx_err(E_MISSEL, "xml parser: missing 'tilewidth' attribute in the 'tileset' element");
return 0;
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"tileheight"))) { /* tile_height */
ts_addr->tile_height = atoi(value);
tmx_free_func(value);
} else {
tmx_err(E_MISSEL, "xml parser: missing 'tileheight' attribute in the 'tileset' element");
return 0;
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"spacing"))) { /* spacing */
ts_addr->spacing = atoi(value);
tmx_free_func(value);
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"margin"))) { /* margin */
ts_addr->margin = atoi(value);
tmx_free_func(value);
}
/* Parse each child */
do {
if (xmlTextReaderRead(reader) != 1) return 0; /* error_handler has been called */
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) {
name = (char*)xmlTextReaderConstName(reader);
if (!strcmp(name, "image")) {
if (!parse_image(reader, &(ts_addr->image), 1, filename)) return 0;
} else if (!strcmp(name, "tileoffset")) {
if (!parse_tileoffset(reader, &(ts_addr->x_offset), &(ts_addr->y_offset))) return 0;
} else if (!strcmp(name, "properties")) {
if (!parse_properties(reader, &(ts_addr->properties))) return 0;
} else if (!strcmp(name, "tile")) {
if (!parse_tile(reader, &(ts_addr->tiles), filename)) return 0;
} else {
/* Unknown element, skip its tree */
if (xmlTextReaderNext(reader) != 1) return 0;
}
}
} while (xmlTextReaderNodeType(reader) != XML_READER_TYPE_END_ELEMENT ||
xmlTextReaderDepth(reader) != curr_depth);
return 1;
}
/* parse layers and objectgroups */
static int parse_layer(xmlTextReaderPtr reader, tmx_layer **layer_headadr, int map_h, int map_w, enum tmx_layer_type type, const char *filename) {
tmx_layer *res;
tmx_object *obj;
int curr_depth;
const char *name;
char *value;
curr_depth = xmlTextReaderDepth(reader);
if (!(res = alloc_layer())) return 0;
res->type = type;
while(*layer_headadr) {
layer_headadr = &((*layer_headadr)->next);
}
*layer_headadr = res;
/* parses each attribute */
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"name"))) { /* name */
res->name = value;
} else {
tmx_err(E_MISSEL, "xml parser: missing 'name' attribute in the 'layer' element");
return 0;
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"visible"))) { /* visible */
res->visible = (char)atoi(value);
tmx_free_func(value);
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"opacity"))) { /* opacity */
res->opacity = (float)strtod(value, NULL);
tmx_free_func(value);
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"color"))) { /* color */
res->color = get_color_rgb(value);
tmx_free_func(value);
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"x"))) { /* x_offset */
res->x_offset = (int)atoi(value);
tmx_free_func(value);
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"y"))) { /* y_offset */
res->y_offset = (int)atoi(value);
tmx_free_func(value);
}
do {
if (xmlTextReaderRead(reader) != 1) return 0; /* error_handler has been called */
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) {
name = (char*)xmlTextReaderConstName(reader);
if (!strcmp(name, "properties")) {
if (!parse_properties(reader, &(res->properties))) return 0;
} else if (!strcmp(name, "data")) {
if (!parse_data(reader, &(res->content.gids), map_h * map_w)) return 0;
} else if (!strcmp(name, "image")) {
if (!parse_image(reader, &(res->content.image), 0, filename)) return 0;
} else if (!strcmp(name, "object")) {
if (!(obj = alloc_object())) return 0;
obj->next = res->content.head;
res->content.head = obj;
if (!parse_object(reader, obj)) return 0;
} else {
/* Unknow element, skip its tree */
if (xmlTextReaderNext(reader) != 1) return 0;
}
}
} while (xmlTextReaderNodeType(reader) != XML_READER_TYPE_END_ELEMENT ||
xmlTextReaderDepth(reader) != curr_depth);
return 1;
}
int CheckReader(EFI_SMART_CARD_READER_PROTOCOL *SmartCardReader)
{
EFI_STATUS rv;
unsigned int i;
unsigned char bSendBuffer[MAX_BUFFER_SIZE];
unsigned char bRecvBuffer[MAX_BUFFER_SIZE];
int send_length;
UINTN length;
int verify_ioctl = 0;
int modify_ioctl = 0;
int pin_properties_ioctl = 0;
int mct_readerdirect_ioctl = 0;
int properties_in_tlv_ioctl = 0;
int ccid_esc_command = 0;
PCSC_TLV_STRUCTURE *pcsc_tlv;
#if defined(VERIFY_PIN) | defined(MODIFY_PIN)
int offset;
#endif
#ifdef VERIFY_PIN
PIN_VERIFY_STRUCTURE *pin_verify;
#endif
#ifdef MODIFY_PIN
PIN_MODIFY_STRUCTURE *pin_modify;
#endif
int PIN_min_size = 4;
int PIN_max_size = 8;
UINT32 ActiveProtocol;
/* table for bEntryValidationCondition
* 0x01: Max size reached
* 0x02: Validation key pressed
* 0x04: Timeout occured
*/
int bEntryValidationCondition = 7;
/* does the reader support PIN verification? */
length = sizeof bRecvBuffer;
rv = SmartCardReader->SCardControl(SmartCardReader,
CM_IOCTL_GET_FEATURE_REQUEST, NULL, 0, bRecvBuffer,
&length);
PCSC_ERROR_EXIT(rv, L"SCardControl")
Print(L" TLV (%ld): ", length);
for (i=0; i<length; i++)
Print(L"%02X ", bRecvBuffer[i]);
Print(L"\n");
PCSC_ERROR_CONT(rv, L"SCardControl(CM_IOCTL_GET_FEATURE_REQUEST)")
if (length % sizeof(PCSC_TLV_STRUCTURE))
{
Print(L"Inconsistent result! Bad TLV values!\n");
goto end;
}
/* get the number of elements instead of the complete size */
length /= sizeof(PCSC_TLV_STRUCTURE);
pcsc_tlv = (PCSC_TLV_STRUCTURE *)bRecvBuffer;
for (i = 0; i < length; i++)
{
switch (pcsc_tlv[i].tag)
{
case FEATURE_VERIFY_PIN_DIRECT:
Print(L"Reader supports FEATURE_VERIFY_PIN_DIRECT\n");
verify_ioctl = ntohl(pcsc_tlv[i].value);
break;
case FEATURE_MODIFY_PIN_DIRECT:
Print(L"Reader supports FEATURE_MODIFY_PIN_DIRECT\n");
modify_ioctl = ntohl(pcsc_tlv[i].value);
break;
case FEATURE_IFD_PIN_PROPERTIES:
Print(L"Reader supports FEATURE_IFD_PIN_PROPERTIES\n");
pin_properties_ioctl = ntohl(pcsc_tlv[i].value);
break;
case FEATURE_MCT_READER_DIRECT:
Print(L"Reader supports FEATURE_MCT_READER_DIRECT\n");
mct_readerdirect_ioctl = ntohl(pcsc_tlv[i].value);
break;
case FEATURE_GET_TLV_PROPERTIES:
Print(L"Reader supports FEATURE_GET_TLV_PROPERTIES\n");
properties_in_tlv_ioctl = ntohl(pcsc_tlv[i].value);
break;
case FEATURE_CCID_ESC_COMMAND:
Print(L"Reader supports FEATURE_CCID_ESC_COMMAND\n");
ccid_esc_command = ntohl(pcsc_tlv[i].value);
break;
default:
Print(L"Can't parse tag", pcsc_tlv[i].tag);
}
}
Print(L"\n");
if (properties_in_tlv_ioctl)
{
int value;
int ret;
length = sizeof bRecvBuffer;
rv = SmartCardReader->SCardControl(SmartCardReader, properties_in_tlv_ioctl, NULL, 0,
bRecvBuffer, &length);
PCSC_ERROR_CONT(rv, L"SCardControl(GET_TLV_PROPERTIES)")
Print(L"GET_TLV_PROPERTIES (%ld): ", length);
for (i=0; i<length; i++)
Print(L"%02X ", bRecvBuffer[i]);
Print(L"\n");
Print(L"\nDisplay all the properties:\n");
parse_properties(bRecvBuffer, length);
Print(L"\nFind a specific property:\n");
ret = PCSCv2Part10_find_TLV_property_by_tag_from_buffer(bRecvBuffer, length, PCSCv2_PART10_PROPERTY_wIdVendor, &value);
if (ret)
Print(L" wIdVendor: %d\n", ret);
else
Print(L" wIdVendor: %04X\n", value);
ret = PCSCv2Part10_find_TLV_property_by_tag_from_protocol(SmartCardReader, PCSCv2_PART10_PROPERTY_wIdProduct, &value);
if (ret)
Print(L" wIdProduct %d\n", ret);
else
Print(L" wIdProduct: %04X\n", value);
ret = PCSCv2Part10_find_TLV_property_by_tag_from_protocol(SmartCardReader, PCSCv2_PART10_PROPERTY_bMinPINSize, &value);
if (0 == ret)
{
PIN_min_size = value;
Print(L" PIN min size defined %d\n", PIN_min_size);
}
ret = PCSCv2Part10_find_TLV_property_by_tag_from_protocol(SmartCardReader, PCSCv2_PART10_PROPERTY_bMaxPINSize, &value);
if (0 == ret)
{
PIN_max_size = value;
Print(L" PIN max size defined %d\n", PIN_max_size);
}
ret = PCSCv2Part10_find_TLV_property_by_tag_from_protocol(SmartCardReader, PCSCv2_PART10_PROPERTY_bEntryValidationCondition, &value);
if (0 == ret)
{
bEntryValidationCondition = value;
Print(L" Entry Validation Condition defined %d\n",
bEntryValidationCondition);
}
Print(L"\n");
}
if (mct_readerdirect_ioctl)
{
unsigned char secoder_info[] = { 0x20, 0x70, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00 };
length = sizeof bRecvBuffer;
rv = SmartCardReader->SCardControl(SmartCardReader,
mct_readerdirect_ioctl, secoder_info, sizeof(secoder_info),
bRecvBuffer, &length);
PCSC_ERROR_CONT(rv, L"SCardControl(MCT_READER_DIRECT)")
Print(L"MCT_READER_DIRECT (%ld): ", length);
for (i=0; i<length; i++)
Print(L"%02X ", bRecvBuffer[i]);
Print(L"\n");
}
if (pin_properties_ioctl)
{
PIN_PROPERTIES_STRUCTURE *pin_properties;
length = sizeof bRecvBuffer;
rv = SmartCardReader->SCardControl(SmartCardReader,
pin_properties_ioctl, NULL, 0, bRecvBuffer, &length);
PCSC_ERROR_CONT(rv, L"SCardControl(pin_properties_ioctl)")
Print(L"PIN PROPERTIES (%ld): ", length);
for (i=0; i<length; i++)
Print(L"%02X ", bRecvBuffer[i]);
Print(L"\n");
pin_properties = (PIN_PROPERTIES_STRUCTURE *)bRecvBuffer;
Print(L" wLcdLayout %04X\n", pin_properties -> wLcdLayout);
Print(L" bEntryValidationCondition %d\n", pin_properties -> bEntryValidationCondition);
Print(L" bTimeOut2 %d\n", pin_properties -> bTimeOut2);
Print(L"\n");
}
if (0 == verify_ioctl)
{
Print(L"Reader does not support PIN verification\n");
goto end;
}
/* SCardConnect */
rv = SmartCardReader->SCardConnect(SmartCardReader,
SCARD_AM_CARD,
SCARD_CA_COLDRESET,
SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1,
&ActiveProtocol);
PCSC_ERROR_EXIT(rv, L"SCardConnect")
/* APDU select applet */
Print(L"Select applet: ");
send_length = 11;
memcpy(bSendBuffer, "\x00\xA4\x04\x00\x06\xA0\x00\x00\x00\x18\xFF",
send_length);
for (i=0; i<send_length; i++)
Print(L" %02X", bSendBuffer[i]);
Print(L"\n");
length = sizeof(bRecvBuffer);
rv = SmartCardReader->SCardTransmit(SmartCardReader,
bSendBuffer, send_length, bRecvBuffer, &length);
Print(L" card response:");
for (i=0; i<length; i++)
Print(L" %02X", bRecvBuffer[i]);
Print(L"\n");
PCSC_ERROR_EXIT(rv, L"SCardTransmit")
if ((bRecvBuffer[0] != 0x90) || (bRecvBuffer[1] != 0x00))
{
Print(L"Error: test applet not found!\n");
goto end;
}
#ifdef VERIFY_PIN
/* verify PIN */
Print(L" Secure verify PIN\n");
pin_verify = (PIN_VERIFY_STRUCTURE *)bSendBuffer;
/* PC/SC v2.02.05 Part 10 PIN verification data structure */
pin_verify -> bTimerOut = 0x00;
pin_verify -> bTimerOut2 = 0x00;
pin_verify -> bmFormatString = 0x82;
pin_verify -> bmPINBlockString = 0x04;
pin_verify -> bmPINLengthFormat = 0x00;
pin_verify -> wPINMaxExtraDigit = (PIN_min_size << 8) + PIN_max_size;
pin_verify -> bEntryValidationCondition = bEntryValidationCondition;
pin_verify -> bNumberMessage = 0x01;
pin_verify -> wLangId = 0x0904;
pin_verify -> bMsgIndex = 0x00;
pin_verify -> bTeoPrologue[0] = 0x00;
pin_verify -> bTeoPrologue[1] = 0x00;
pin_verify -> bTeoPrologue[2] = 0x00;
/* pin_verify -> ulDataLength = 0x00; we don't know the size yet */
/* APDU: 00 20 00 00 08 30 30 30 30 00 00 00 00 */
offset = 0;
pin_verify -> abData[offset++] = 0x00; /* CLA */
pin_verify -> abData[offset++] = 0x20; /* INS: VERIFY */
pin_verify -> abData[offset++] = 0x00; /* P1 */
pin_verify -> abData[offset++] = 0x00; /* P2 */
pin_verify -> abData[offset++] = 0x08; /* Lc: 8 data bytes */
pin_verify -> abData[offset++] = 0x30; /* '0' */
pin_verify -> abData[offset++] = 0x30; /* '0' */
pin_verify -> abData[offset++] = 0x30; /* '0' */
pin_verify -> abData[offset++] = 0x30; /* '0' */
pin_verify -> abData[offset++] = 0x00; /* '\0' */
pin_verify -> abData[offset++] = 0x00; /* '\0' */
pin_verify -> abData[offset++] = 0x00; /* '\0' */
pin_verify -> abData[offset++] = 0x00; /* '\0' */
pin_verify -> ulDataLength = offset; /* APDU size */
send_length = sizeof(PIN_VERIFY_STRUCTURE) + offset;
Print(L" command:");
for (i=0; i<length; i++)
Print(L" %02X", bSendBuffer[i]);
Print(L"\n");
Print(L"Enter your PIN: \n");
length = sizeof bRecvBuffer;
rv = SmartCardReader->SCardControl(SmartCardReader, verify_ioctl,
bSendBuffer, send_length, bRecvBuffer, &length);
Print(L" card response:");
for (i=0; i<length; i++)
Print(L" %02X", bRecvBuffer[i]);
Print(L": %s\n", pinpad_return_codes(bRecvBuffer));
PCSC_ERROR_CONT(rv, L"SCardControl")
/* verify PIN dump */
Print(L"\nverify PIN dump: ");
send_length = 5;
memcpy(bSendBuffer, "\x00\x40\x00\x00\xFF",
send_length);
for (i=0; i<send_length; i++)
Print(L" %02X", bSendBuffer[i]);
Print(L"\n");
length = sizeof(bRecvBuffer);
rv = SmartCardReader->SCardTransmit(SmartCardReader, bSendBuffer, send_length,
bRecvBuffer, &length);
Print(L" card response:");
for (i=0; i<length; i++)
Print(L" %02X", bRecvBuffer[i]);
Print(L"\n");
PCSC_ERROR_EXIT(rv, L"SCardTransmit")
if ((2 == length) && (0x6C == bRecvBuffer[0]))
{
Print(L"\nverify PIN dump: ");
send_length = 5;
memcpy(bSendBuffer, "\x00\x40\x00\x00\xFF",
send_length);
bSendBuffer[4] = bRecvBuffer[1];
for (i=0; i<send_length; i++)
Print(L" %02X", bSendBuffer[i]);
Print(L"\n");
length = sizeof(bRecvBuffer);
rv = SmartCardReader->SCardTransmit(SmartCardReader, bSendBuffer, send_length,
bRecvBuffer, &length);
Print(L" card response:");
for (i=0; i<length; i++)
Print(L" %02X", bRecvBuffer[i]);
Print(L"\n");
PCSC_ERROR_EXIT(rv, L"SCardTransmit")
}
/**
* Load a graph file but using a set of externally provided buffers
* for the data. This might be useful in the case that you want to managed
* memory for the graph independently of this function.
*
* To maintain the graph, only the bvgraph structure, and the two
* external ararys: gmemory and offsets are required. Consequently,
* a bvgraph structure can always be patched together out of these
* functions.
*
* One common way of using this function would be to first
* load a graph on the disk (bvgraph_load(...,offset_step=-1))
* and then call bvgraph_required_memory with an alternative
* offset step.
*
* @param[in] g a newly created bvgraph structure
* @param[in] filename the base filename for a set of bvgraph files,
* so filename.graph and filename.properties must exist.
* @param[in] offset_step controls how many offsets are loaded,
* if offset_step = -1, then the graph file isn't loaded into memory
* if offset_step = 0, then the graph file is loaded, but no offsets
* no other values are supported at the moment.
* @param[in] gmemory an arry of size gmemsize for the graph
* (if NULL, then this parameter is treated as internal memory)
* @param[in] gmemsize the size of the gmemory block
* @param[in] offsets an array of offsets
* (if NULL, then this parameter is treated as internal memory)
* @param[in] offsetssize the number of offsets
* @return 0 if successful;
* bvgraph_load_error_filename_too_long - indicates the filename was too long
*/
int bvgraph_load_external(bvgraph *g,
const char *filename, unsigned int filenamelen, int offset_step,
unsigned char *gmemory, size_t gmemsize,
unsigned long long* offsets, int offsetssize)
{
int rval = 0;
assert(offset_step == 0 || offset_step == -1 || offset_step == 1);
if (filenamelen > BVGRAPH_MAX_FILENAME_SIZE-1) {
return bvgraph_load_error_filename_too_long;
}
memset(g,0,sizeof(bvgraph));
strncpy(g->filename, filename, filenamelen);
g->filename[filenamelen] = '\0';
g->filenamelen = filenamelen;
g->offset_step = offset_step;
set_defaults(g);
rval = parse_properties(g);
// check for any errors
if (rval != 0) { return rval; }
// continue processing
if (offset_step >= 0)
{
if (offset_step == 0 || offset_step == 1) { //modified 082911
// in this case, we ust load the graph
// file into memory
// first get the filesize
unsigned long long graphfilesize;
char *gfilename = strappend(g->filename, g->filenamelen, ".graph", 6);
rval = fsize(gfilename, &graphfilesize);
free(gfilename);
if (rval) {
return bvgraph_call_io_error;
}
if (gmemory != NULL) {
// they want to use their own memory, make sure
// they allocated enough!
if (gmemsize < graphfilesize) {
return bvgraph_load_error_buffer_too_small;
}
g->memory = gmemory;
g->memory_size = gmemsize;
g->memory_external = 1;
} else {
// we have to allocate the memory ourselves
g->memory_size = (size_t)graphfilesize;
g->memory = malloc(sizeof(unsigned char)*g->memory_size);
if (!g->memory) {
return bvgraph_call_out_of_memory;
}
g->memory_external = 0;
}
// now read the file
gfilename = strappend(g->filename, g->filenamelen, ".graph", 6);
{
size_t bytesread = 0;
FILE *gfile = fopen(gfilename, "rb");
free(gfilename);
if (!gfile) {
return bvgraph_call_io_error;
}
bytesread = fread(g->memory, 1, g->memory_size, gfile);
if (bytesread != graphfilesize) {
return bvgraph_call_io_error;
}
fclose(gfile);
}
// we now have the graph in memory!
if (offset_step == 1) { //modified 082911
// now read the file
char *ofilename = strappend(g->filename, g->filenamelen, ".offsets", 8);
bitfile bf;
long long off = 0;
int64_t i;
FILE *ofile = fopen(ofilename, "rb");
if (offsets != NULL) {
g->offsets = offsets;
g->offsets_external = 1;
} else {
// we have to allocate the memory ourselves
g->offsets = (unsigned long long*) malloc(sizeof(unsigned long long)*g->n);
g->offsets_external = 0;
}
if (ofile) {
rval = bitfile_open(ofile, &bf);
if (rval) {
return bvgraph_call_io_error;
}
for (i = 0; i < g->n; i++){
off = read_offset(g, &bf) + off;
g->offsets[i] = off;
}
} else {
// need to build the offsets
bvgraph_iterator git;
int rval = bvgraph_nonzero_iterator(g, &git);
if (rval) { return rval; }
g->offsets[0] = 0;
for (; bvgraph_iterator_valid(&git); bvgraph_iterator_next(&git)) {
if (git.curr+1 < g->n) {
g->offsets[git.curr+1] = bitfile_tell(&git.bf);
}
}
bvgraph_iterator_free(&git);
}
}
}
}
else
{
g->memory_size = 0;
}
// presently the othercases are not supported, so we don't have to
// worry about them!
return (0);
}
int main(int argc, char *argv[])
{
LONG rv;
SCARDCONTEXT hContext;
DWORD dwReaders;
LPSTR mszReaders = NULL;
char *ptr, **readers = NULL;
int nbReaders;
SCARDHANDLE hCard;
DWORD dwActiveProtocol, dwReaderLen, dwState, dwProt, dwAtrLen;
BYTE pbAtr[MAX_ATR_SIZE] = "";
char pbReader[MAX_READERNAME] = "";
int reader_nb;
unsigned int i;
unsigned char bSendBuffer[MAX_BUFFER_SIZE];
unsigned char bRecvBuffer[MAX_BUFFER_SIZE];
DWORD send_length, length;
DWORD verify_ioctl = 0;
DWORD modify_ioctl = 0;
DWORD pin_properties_ioctl = 0;
DWORD mct_readerdirect_ioctl = 0;
DWORD properties_in_tlv_ioctl = 0;
DWORD ccid_esc_command = 0;
SCARD_IO_REQUEST pioRecvPci;
SCARD_IO_REQUEST pioSendPci;
PCSC_TLV_STRUCTURE *pcsc_tlv;
#if defined(VERIFY_PIN) | defined(MODIFY_PIN)
int offset;
#endif
#ifdef VERIFY_PIN
PIN_VERIFY_STRUCTURE *pin_verify;
#endif
#ifdef MODIFY_PIN
PIN_MODIFY_STRUCTURE *pin_modify;
#endif
printf("SCardControl sample code\n");
printf("V 1.4 © 2004-2010, Ludovic Rousseau <*****@*****.**>\n\n");
printf(MAGENTA "THIS PROGRAM IS NOT DESIGNED AS A TESTING TOOL!\n");
printf("Do NOT use it unless you really know what you do.\n\n" NORMAL);
rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &hContext);
if (rv != SCARD_S_SUCCESS)
{
printf("SCardEstablishContext: Cannot Connect to Resource Manager %ulX\n", rv);
return 1;
}
/* Retrieve the available readers list */
rv = SCardListReaders(hContext, NULL, NULL, &dwReaders);
PCSC_ERROR_EXIT(rv, "SCardListReaders")
mszReaders = malloc(sizeof(char)*dwReaders);
if (mszReaders == NULL)
{
printf("malloc: not enough memory\n");
goto end;
}
rv = SCardListReaders(hContext, NULL, mszReaders, &dwReaders);
if (rv != SCARD_S_SUCCESS)
printf("SCardListReader: %ulX\n", rv);
/* Extract readers from the null separated string and get the total
* number of readers */
nbReaders = 0;
ptr = mszReaders;
while (*ptr != '\0')
{
ptr += strlen(ptr)+1;
nbReaders++;
}
if (nbReaders == 0)
{
printf("No reader found\n");
goto end;
}
/* allocate the readers table */
readers = calloc(nbReaders, sizeof(char *));
if (NULL == readers)
{
printf("Not enough memory for readers[]\n");
goto end;
}
/* fill the readers table */
nbReaders = 0;
ptr = mszReaders;
printf("Available readers (use command line argument to select)\n");
while (*ptr != '\0')
{
printf("%d: %s\n", nbReaders, ptr);
readers[nbReaders] = ptr;
ptr += strlen(ptr)+1;
nbReaders++;
}
printf("\n");
if (argc > 1)
{
reader_nb = atoi(argv[1]);
if (reader_nb < 0 || reader_nb >= nbReaders)
{
printf("Wrong reader index: %d\n", reader_nb);
goto end;
}
}
else
reader_nb = 0;
/* connect to a reader (even without a card) */
dwActiveProtocol = -1;
printf("Using reader: " GREEN "%s\n" NORMAL, readers[reader_nb]);
rv = SCardConnect(hContext, readers[reader_nb], SCARD_SHARE_SHARED,
SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1, &hCard, &dwActiveProtocol);
printf(" Protocol: " GREEN "%uld\n" NORMAL, dwActiveProtocol);
PCSC_ERROR_EXIT(rv, "SCardConnect")
#ifdef GET_GEMPC_FIRMWARE
/* get GemPC firmware */
printf(" Get GemPC Firmware\n");
/* this is specific to Gemalto readers */
bSendBuffer[0] = 0x02;
rv = SCardControl(hCard, IOCTL_SMARTCARD_VENDOR_IFD_EXCHANGE, bSendBuffer,
1, bRecvBuffer, sizeof(bRecvBuffer), &length);
printf(" Firmware: " GREEN);
for (i=0; i<length; i++)
printf("%02X ", bRecvBuffer[i]);
printf(NORMAL "\n");
bRecvBuffer[length] = '\0';
printf(" Firmware: " GREEN "%s" NORMAL" (length " GREEN "%ld" NORMAL " bytes)\n", bRecvBuffer, length);
PCSC_ERROR_CONT(rv, "SCardControl")
#endif
/* does the reader support PIN verification? */
rv = SCardControl(hCard, CM_IOCTL_GET_FEATURE_REQUEST, NULL, 0,
bRecvBuffer, sizeof(bRecvBuffer), &length);
PCSC_ERROR_EXIT(rv, "SCardControl")
printf(" TLV (%uld): " GREEN, length);
for (i=0; i<length; i++)
printf("%02X ", bRecvBuffer[i]);
printf(NORMAL "\n");
PCSC_ERROR_CONT(rv, "SCardControl(CM_IOCTL_GET_FEATURE_REQUEST)")
if (length % sizeof(PCSC_TLV_STRUCTURE))
{
printf("Inconsistent result! Bad TLV values!\n");
goto end;
}
/* get the number of elements instead of the complete size */
length /= sizeof(PCSC_TLV_STRUCTURE);
pcsc_tlv = (PCSC_TLV_STRUCTURE *)bRecvBuffer;
for (i = 0; i < length; i++)
{
switch (pcsc_tlv[i].tag)
{
case FEATURE_VERIFY_PIN_DIRECT:
PRINT_GREEN("Reader supports", "FEATURE_VERIFY_PIN_DIRECT");
verify_ioctl = ntohl(pcsc_tlv[i].value);
break;
case FEATURE_MODIFY_PIN_DIRECT:
PRINT_GREEN("Reader supports", "FEATURE_MODIFY_PIN_DIRECT");
modify_ioctl = ntohl(pcsc_tlv[i].value);
break;
case FEATURE_IFD_PIN_PROPERTIES:
PRINT_GREEN("Reader supports", "FEATURE_IFD_PIN_PROPERTIES");
pin_properties_ioctl = ntohl(pcsc_tlv[i].value);
break;
case FEATURE_MCT_READER_DIRECT:
PRINT_GREEN("Reader supports", "FEATURE_MCT_READER_DIRECT");
mct_readerdirect_ioctl = ntohl(pcsc_tlv[i].value);
break;
case FEATURE_GET_TLV_PROPERTIES:
PRINT_GREEN("Reader supports", "FEATURE_GET_TLV_PROPERTIES");
properties_in_tlv_ioctl = ntohl(pcsc_tlv[i].value);
break;
case FEATURE_CCID_ESC_COMMAND:
PRINT_GREEN("Reader supports", "FEATURE_CCID_ESC_COMMAND");
ccid_esc_command = ntohl(pcsc_tlv[i].value);
break;
default:
PRINT_RED_DEC("Can't parse tag", pcsc_tlv[i].tag);
}
}
printf("\n");
if (properties_in_tlv_ioctl)
{
int value;
int ret;
rv = SCardControl(hCard, properties_in_tlv_ioctl, NULL, 0,
bRecvBuffer, sizeof(bRecvBuffer), &length);
PCSC_ERROR_CONT(rv, "SCardControl(GET_TLV_PROPERTIES)")
printf("GET_TLV_PROPERTIES (" GREEN "%uld" NORMAL "): " GREEN, length);
for (i=0; i<length; i++)
printf("%02X ", bRecvBuffer[i]);
printf(NORMAL "\n");
printf("\nDisplay all the properties:\n");
parse_properties(bRecvBuffer, length);
printf("\nFind a specific property:\n");
ret = PCSCv2Part10_find_TLV_property_by_tag_from_buffer(bRecvBuffer, length, PCSCv2_PART10_PROPERTY_wIdVendor, &value);
if (ret)
PRINT_RED_DEC(" wIdVendor", ret);
else
PRINT_GREEN_HEX4(" wIdVendor", value);
ret = PCSCv2Part10_find_TLV_property_by_tag_from_hcard(hCard, PCSCv2_PART10_PROPERTY_wIdProduct, &value);
if (ret)
PRINT_RED_DEC(" wIdProduct", ret);
else
PRINT_GREEN_HEX4(" wIdProduct", value);
printf("\n");
}
if (mct_readerdirect_ioctl)
{
char secoder_info[] = { 0x20, 0x70, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00 };
rv = SCardControl(hCard, mct_readerdirect_ioctl, secoder_info,
sizeof(secoder_info), bRecvBuffer, sizeof(bRecvBuffer), &length);
PCSC_ERROR_CONT(rv, "SCardControl(MCT_READER_DIRECT)")
printf("MCT_READER_DIRECT (%uld): ", length);
for (i=0; i<length; i++)
printf("%02X ", bRecvBuffer[i]);
printf("\n");
}
if (pin_properties_ioctl)
{
PIN_PROPERTIES_STRUCTURE *pin_properties;
rv = SCardControl(hCard, pin_properties_ioctl, NULL, 0,
bRecvBuffer, sizeof(bRecvBuffer), &length);
PCSC_ERROR_CONT(rv, "SCardControl(pin_properties_ioctl)")
printf("PIN PROPERTIES (" GREEN "%uld" NORMAL "): " GREEN, length);
for (i=0; i<length; i++)
printf("%02X ", bRecvBuffer[i]);
printf(NORMAL "\n");
pin_properties = (PIN_PROPERTIES_STRUCTURE *)bRecvBuffer;
PRINT_GREEN_HEX4(" wLcdLayout", pin_properties -> wLcdLayout);
PRINT_GREEN_DEC(" bEntryValidationCondition", pin_properties -> bEntryValidationCondition);
PRINT_GREEN_DEC(" bTimeOut2", pin_properties -> bTimeOut2);
printf("\n");
}
#ifdef GET_GEMPC_FIRMWARE
if (ccid_esc_command)
{
/* get GemPC firmware */
printf("Get GemPC Firmware\n");
/* this is specific to Gemalto readers */
bSendBuffer[0] = 0x02;
rv = SCardControl(hCard, ccid_esc_command, bSendBuffer,
1, bRecvBuffer, sizeof(bRecvBuffer), &length);
printf(" Firmware: " GREEN);
for (i=0; i<length; i++)
printf("%02X ", bRecvBuffer[i]);
printf(NORMAL "\n");
bRecvBuffer[length] = '\0';
printf(" Firmware: " GREEN "%s" NORMAL" (length " GREEN "%ld" NORMAL " bytes)\n", bRecvBuffer, length);
PCSC_ERROR_CONT(rv, "SCardControl")
}
#endif
if (0 == verify_ioctl)
{
printf("Reader %s does not support PIN verification\n",
readers[reader_nb]);
goto end;
}
/* get card status */
dwAtrLen = sizeof(pbAtr);
dwReaderLen = sizeof(pbReader);
rv = SCardStatus(hCard, pbReader, &dwReaderLen, &dwState, &dwProt,
pbAtr, &dwAtrLen);
printf(" Reader: %s (length %uld bytes)\n", pbReader, dwReaderLen);
printf(" State: 0x%04ulX\n", dwState);
printf(" Prot: %uld\n", dwProt);
printf(" ATR (length %uld bytes):", dwAtrLen);
for (i=0; i<dwAtrLen; i++)
printf(" %02X", pbAtr[i]);
printf("\n");
PCSC_ERROR_CONT(rv, "SCardStatus")
if (dwState & SCARD_ABSENT)
{
printf("No card inserted\n");
goto end;
}
/* connect to a reader (even without a card) */
dwActiveProtocol = -1;
rv = SCardReconnect(hCard, SCARD_SHARE_SHARED,
SCARD_PROTOCOL_T0|SCARD_PROTOCOL_T1, SCARD_LEAVE_CARD,
&dwActiveProtocol);
printf(" Protocol: %uld\n", dwActiveProtocol);
PCSC_ERROR_EXIT(rv, "SCardReconnect")
switch(dwActiveProtocol)
{
case SCARD_PROTOCOL_T0:
pioSendPci = *SCARD_PCI_T0;
break;
case SCARD_PROTOCOL_T1:
pioSendPci = *SCARD_PCI_T1;
break;
default:
printf("Unknown protocol. No card present?\n");
return -1;
}
/* APDU select applet */
printf("Select applet: ");
send_length = 11;
memcpy(bSendBuffer, "\x00\xA4\x04\x00\x06\xA0\x00\x00\x00\x18\xFF",
send_length);
for (i=0; i<send_length; i++)
printf(" %02X", bSendBuffer[i]);
printf("\n");
length = sizeof(bRecvBuffer);
rv = SCardTransmit(hCard, &pioSendPci, bSendBuffer, send_length,
&pioRecvPci, bRecvBuffer, &length);
printf(" card response:");
for (i=0; i<length; i++)
printf(" %02X", bRecvBuffer[i]);
printf("\n");
PCSC_ERROR_EXIT(rv, "SCardTransmit")
if ((bRecvBuffer[0] != 0x90) || (bRecvBuffer[1] != 0x00))
{
printf("Error: test applet not found!\n");
goto end;
}
#ifdef VERIFY_PIN
/* verify PIN */
printf(" Secure verify PIN\n");
pin_verify = (PIN_VERIFY_STRUCTURE *)bSendBuffer;
/* table for bEntryValidationCondition
* 0x01: Max size reached
* 0x02: Validation key pressed
* 0x04: Timeout occured
*/
/* PC/SC v2.02.05 Part 10 PIN verification data structure */
pin_verify -> bTimerOut = 0x00;
pin_verify -> bTimerOut2 = 0x00;
pin_verify -> bmFormatString = 0x82;
pin_verify -> bmPINBlockString = 0x04;
pin_verify -> bmPINLengthFormat = 0x00;
pin_verify -> wPINMaxExtraDigit = 0x0408; /* Min Max */
pin_verify -> bEntryValidationCondition = 0x02; /* validation key pressed */
pin_verify -> bNumberMessage = 0x01;
pin_verify -> wLangId = 0x0904;
pin_verify -> bMsgIndex = 0x00;
pin_verify -> bTeoPrologue[0] = 0x00;
pin_verify -> bTeoPrologue[1] = 0x00;
pin_verify -> bTeoPrologue[2] = 0x00;
/* pin_verify -> ulDataLength = 0x00; we don't know the size yet */
/* APDU: 00 20 00 00 08 30 30 30 30 00 00 00 00 */
offset = 0;
pin_verify -> abData[offset++] = 0x00; /* CLA */
pin_verify -> abData[offset++] = 0x20; /* INS: VERIFY */
pin_verify -> abData[offset++] = 0x00; /* P1 */
pin_verify -> abData[offset++] = 0x00; /* P2 */
pin_verify -> abData[offset++] = 0x08; /* Lc: 8 data bytes */
pin_verify -> abData[offset++] = 0x30; /* '0' */
pin_verify -> abData[offset++] = 0x30; /* '0' */
pin_verify -> abData[offset++] = 0x30; /* '0' */
pin_verify -> abData[offset++] = 0x30; /* '0' */
pin_verify -> abData[offset++] = 0x00; /* '\0' */
pin_verify -> abData[offset++] = 0x00; /* '\0' */
pin_verify -> abData[offset++] = 0x00; /* '\0' */
pin_verify -> abData[offset++] = 0x00; /* '\0' */
pin_verify -> ulDataLength = offset; /* APDU size */
length = sizeof(PIN_VERIFY_STRUCTURE) + offset -1; /* -1 because PIN_VERIFY_STRUCTURE contains the first byte of abData[] */
printf(" command:");
for (i=0; i<length; i++)
printf(" %02X", bSendBuffer[i]);
printf("\n");
printf("Enter your PIN: ");
fflush(stdout);
rv = SCardControl(hCard, verify_ioctl, bSendBuffer,
length, bRecvBuffer, sizeof(bRecvBuffer), &length);
{
#ifndef S_SPLINT_S
fd_set fd;
#endif
struct timeval timeout;
FD_ZERO(&fd);
FD_SET(STDIN_FILENO, &fd); /* stdin */
timeout.tv_sec = 0; /* timeout = 0.1s */
timeout.tv_usec = 100000;
/* we only try to read stdin if the pinpad is on a keyboard
* we do not read stdin for a SPR 532 for example */
if (select(1, &fd, NULL, NULL, &timeout) > 0)
{
/* read the fake digits */
char in[40]; /* 4 digits + \n + \0 */
(void)fgets(in, sizeof(in), stdin);
printf("keyboard sent: %s", in);
}
else
/* if it is not a keyboard */
printf("\n");
}
printf(" card response:");
for (i=0; i<length; i++)
printf(" %02X", bRecvBuffer[i]);
printf("\n");
PCSC_ERROR_CONT(rv, "SCardControl")
/* verify PIN dump */
printf("\nverify PIN dump: ");
send_length = 5;
memcpy(bSendBuffer, "\x00\x40\x00\x00\xFF",
send_length);
for (i=0; i<send_length; i++)
printf(" %02X", bSendBuffer[i]);
printf("\n");
length = sizeof(bRecvBuffer);
rv = SCardTransmit(hCard, &pioSendPci, bSendBuffer, send_length,
&pioRecvPci, bRecvBuffer, &length);
printf(" card response:");
for (i=0; i<length; i++)
printf(" %02X", bRecvBuffer[i]);
printf("\n");
PCSC_ERROR_EXIT(rv, "SCardTransmit")
if ((2 == length) && (0x6C == bRecvBuffer[0]))
{
printf("\nverify PIN dump: ");
send_length = 5;
memcpy(bSendBuffer, "\x00\x40\x00\x00\xFF",
send_length);
bSendBuffer[4] = bRecvBuffer[1];
for (i=0; i<send_length; i++)
printf(" %02X", bSendBuffer[i]);
printf("\n");
length = sizeof(bRecvBuffer);
rv = SCardTransmit(hCard, &pioSendPci, bSendBuffer, send_length,
&pioRecvPci, bRecvBuffer, &length);
printf(" card response:");
for (i=0; i<length; i++)
printf(" %02X", bRecvBuffer[i]);
printf("\n");
PCSC_ERROR_EXIT(rv, "SCardTransmit")
}
static int parse_object(xmlTextReaderPtr reader, tmx_object *obj) {
int curr_depth;
const char *name;
char *value;
/* parses each attribute */
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"x"))) { /* x */
obj->x = atof(value);
tmx_free_func(value);
} else {
tmx_err(E_MISSEL, "xml parser: missing 'x' attribute in the 'object' element");
return 0;
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"y"))) { /* y */
obj->y = atof(value);
tmx_free_func(value);
} else {
tmx_err(E_MISSEL, "xml parser: missing 'y' attribute in the 'object' element");
return 0;
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"name"))) { /* name */
obj->name = value;
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"visible"))) { /* visible */
obj->visible = (char)atoi(value);
tmx_free_func(value);
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"height"))) { /* height */
obj->shape = S_SQUARE;
obj->height = atof(value);
tmx_free_func(value);
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"width"))) { /* width */
obj->width = atof(value);
tmx_free_func(value);
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"gid"))) { /* gid */
obj->shape = S_TILE;
obj->gid = atoi(value);
tmx_free_func(value);
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"rotation"))) { /* rotation */
obj->rotation = atof(value);
tmx_free_func(value);
}
/* If it has a child, then it's a polygon or a polyline or an ellipse */
curr_depth = xmlTextReaderDepth(reader);
if (!xmlTextReaderIsEmptyElement(reader)) {
do {
if (xmlTextReaderRead(reader) != 1) return 0; /* error_handler has been called */
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) {
name = (char*)xmlTextReaderConstName(reader);
if (!strcmp(name, "properties")) {
if (!parse_properties(reader, &(obj->properties))) return 0;
} else if (!strcmp(name, "ellipse")) {
obj->shape = S_ELLIPSE;
} else {
if (!strcmp(name, "polygon")) {
obj->shape = S_POLYGON;
} else if (!strcmp(name, "polyline")) {
obj->shape = S_POLYLINE;
}
/* Unknow element, skip its tree */
else if (xmlTextReaderNext(reader) != 1) return 0;
if (!parse_points(reader, &(obj->points), &(obj->points_len))) return 0;
}
}
} while (xmlTextReaderNodeType(reader) != XML_READER_TYPE_END_ELEMENT ||
xmlTextReaderDepth(reader) != curr_depth);
}
return 1;
}
