void fill_pathname_dir(char *in_dir, const char *in_basename, const char *replace, size_t size) { const char *base = NULL; fill_pathname_slash(in_dir, size); base = path_basename(in_basename); rarch_assert(strlcat(in_dir, base, size) < size); rarch_assert(strlcat(in_dir, replace, size) < size); }
void fill_pathname_join(char *out_path, const char *dir, const char *path, size_t size) { rarch_assert(strlcpy(out_path, dir, size) < size); if (*out_path) fill_pathname_slash(out_path, size); rarch_assert(strlcat(out_path, path, size) < size); }
void fill_pathname_join_delim(char *out_path, const char *dir, const char *path, const char delim, size_t size) { size_t copied = strlcpy(out_path, dir, size); rarch_assert(copied < size+1); out_path[copied]=delim; out_path[copied+1] = '\0'; rarch_assert(strlcat(out_path, path, size) < size); }
void rarch_main_data_nbio_init_msg_queue(void) { nbio_handle_t *nbio = (nbio_handle_t*)nbio_ptr; if (!nbio) return; if (!nbio->msg_queue) rarch_assert(nbio->msg_queue = msg_queue_new(8)); if (!nbio->image.msg_queue) rarch_assert(nbio->image.msg_queue = msg_queue_new(8)); }
void rarch_main_data_init_queues(void) { #ifdef HAVE_NETWORKING if (!g_data_runloop.http.msg_queue) rarch_assert(g_data_runloop.http.msg_queue = msg_queue_new(8)); #endif if (!g_data_runloop.nbio.msg_queue) rarch_assert(g_data_runloop.nbio.msg_queue = msg_queue_new(8)); if (!g_data_runloop.nbio.image.msg_queue) rarch_assert(g_data_runloop.nbio.image.msg_queue = msg_queue_new(8)); }
void fill_pathname_resolve_relative(char *out_path, const char *in_refpath, const char *in_path, size_t size) { if (path_is_absolute(in_path)) rarch_assert(strlcpy(out_path, in_path, size) < size); else { rarch_assert(strlcpy(out_path, in_refpath, size) < size); path_basedir(out_path); rarch_assert(strlcat(out_path, in_path, size) < size); } }
void fill_pathname_abbreviate_special(char *out_path, const char *in_path, size_t size) { #if !defined(RARCH_CONSOLE) unsigned i; const char *candidates[3]; const char *notations[3]; char application_dir[PATH_MAX_LENGTH] = {0}; const char *home = getenv("HOME"); /* application_dir could be zero-string. Safeguard against this. * * Keep application dir in front of home, moving app dir to a * new location inside home would break otherwise. */ /* ugly hack - use application_dir pointer before filling it in. C89 reasons */ candidates[0] = application_dir; candidates[1] = home; candidates[2] = NULL; notations [0] = ":"; notations [1] = "~"; notations [2] = NULL; fill_pathname_application_path(application_dir, sizeof(application_dir)); path_basedir(application_dir); for (i = 0; candidates[i]; i++) { if (*candidates[i] && strstr(in_path, candidates[i]) == in_path) { size_t src_size = strlcpy(out_path, notations[i], size); rarch_assert(src_size < size); out_path += src_size; size -= src_size; in_path += strlen(candidates[i]); if (!path_char_is_slash(*in_path)) { rarch_assert(strlcpy(out_path, path_default_slash(), size) < size); out_path++; size--; } break; /* Don't allow more abbrevs to take place. */ } } #endif rarch_assert(strlcpy(out_path, in_path, size) < size); }
void fill_pathname(char *out_path, const char *in_path, const char *replace, size_t size) { char tmp_path[PATH_MAX]; char *tok; rarch_assert(strlcpy(tmp_path, in_path, sizeof(tmp_path)) < sizeof(tmp_path)); if ((tok = (char*)strrchr(path_basename(tmp_path), '.'))) *tok = '\0'; rarch_assert(strlcpy(out_path, tmp_path, size) < size); rarch_assert(strlcat(out_path, replace, size) < size); }
/* Assumes path is a directory. Appends a slash * if not already there. */ void fill_pathname_slash(char *path, size_t size) { size_t path_len = strlen(path); const char *last_slash = find_last_slash(path); // Try to preserve slash type. if (last_slash && (last_slash != (path + path_len - 1))) { char join_str[2] = {*last_slash}; rarch_assert(strlcat(path, join_str, size) < size); } else if (!last_slash) rarch_assert(strlcat(path, path_default_slash(), size) < size); }
void path_resolve_realpath(char *buf, size_t size) { #ifndef RARCH_CONSOLE char tmp[PATH_MAX]; strlcpy(tmp, buf, sizeof(tmp)); #ifdef _WIN32 if (!_fullpath(buf, tmp, size)) strlcpy(buf, tmp, size); #else rarch_assert(size >= PATH_MAX); /* NOTE: realpath() expects at least PATH_MAX bytes in buf. * Technically, PATH_MAX needn't be defined, but we rely on it anyways. * POSIX 2008 can automatically allocate for you, * but don't rely on that. */ if (!realpath(tmp, buf)) strlcpy(buf, tmp, size); #endif #else (void)buf; (void)size; #endif }
void rarch_main_data_init_queues(void) { data_runloop_t *runloop = rarch_main_data_get_ptr(); #ifdef HAVE_NETWORKING if (!runloop->http.msg_queue) rarch_assert(runloop->http.msg_queue = msg_queue_new(8)); #endif if (!runloop->nbio.msg_queue) rarch_assert(runloop->nbio.msg_queue = msg_queue_new(8)); if (!runloop->nbio.image.msg_queue) rarch_assert(runloop->nbio.image.msg_queue = msg_queue_new(8)); #ifdef HAVE_LIBRETRODB if (!runloop->db.msg_queue) rarch_assert(runloop->db.msg_queue = msg_queue_new(8)); #endif }
void init_libretro_sym(bool dummy) { // Guarantee that we can do "dirty" casting. // Every OS that this program supports should pass this ... rarch_assert(sizeof(void*) == sizeof(void (*)(void))); if (!dummy) { #ifdef HAVE_DYNAMIC // Try to verify that -lretro was not linked in from other modules // since loading it dynamically and with -l will fail hard. function_t sym = dylib_proc(NULL, "retro_init"); if (sym) { RARCH_ERR("Serious problem. RetroArch wants to load libretro dyamically, but it is already linked.\n"); RARCH_ERR("This could happen if other modules RetroArch depends on link against libretro directly.\n"); RARCH_ERR("Proceeding could cause a crash. Aborting ...\n"); rarch_fail(1, "init_libretro_sym()"); } if (!*g_settings.libretro) { RARCH_ERR("RetroArch is built for dynamic libretro, but libretro_path is not set. Cannot continue.\n"); rarch_fail(1, "init_libretro_sym()"); } #endif } load_symbols(dummy); pretro_set_environment(environment_cb); }
/** * fill_short_pathname_representation: * @out_rep : output representation * @in_path : input path * @size : size of output representation * * Generates a short representation of path. It should only * be used for displaying the result; the output representation is not * binding in any meaningful way (for a normal path, this is the same as basename) * In case of more complex URLs, this should cut everything except for * the main image file. * * E.g.: "/path/to/game.img" -> game.img * "/path/to/myarchive.7z#folder/to/game.img" -> game.img */ void fill_short_pathname_representation(char* out_rep, const char *in_path, size_t size) { char path_short[PATH_MAX_LENGTH] = {0}; char *last_hash = NULL; fill_pathname(path_short, path_basename(in_path), "", sizeof(path_short)); last_hash = (char*)strchr(path_short,'#'); /* We handle paths like: * /path/to/file.7z#mygame.img * short_name: mygame.img: */ if(last_hash != NULL) { /* We check whether something is actually * after the hash to avoid going over the buffer. */ rarch_assert(strlen(last_hash) > 1); strlcpy(out_rep,last_hash + 1, size); } else strlcpy(out_rep,path_short, size); }
void rarch_main_data_db_init_msg_queue(void) { db_handle_t *db = (db_handle_t*)rarch_main_data_db_get_ptr(); if (!db->msg_queue) rarch_assert(db->msg_queue = msg_queue_new(8)); }
static void vg_copy_frame(void *data, const void *frame, unsigned width, unsigned height, unsigned pitch) { vg_t *vg = (vg_t*)data; if (vg->mEglImageBuf) { EGLImageKHR img = 0; bool new_egl = vg->driver->write_egl_image(frame, width, height, pitch, (vg->mTexType == VG_sXRGB_8888), 0, &img); rarch_assert(img != EGL_NO_IMAGE_KHR); if (new_egl) { vgDestroyImage(vg->mImage); vg->mImage = pvgCreateEGLImageTargetKHR((VGeglImageKHR) img); if (!vg->mImage) { RARCH_ERR("[VG:EGLImage] Error creating image: %08x\n", vgGetError()); exit(2); } vg->last_egl_image = img; } } else { vgImageSubData(vg->mImage, frame, pitch, vg->mTexType, 0, 0, width, height); } }
void fill_pathname_base(char *out, const char *in_path, size_t size) { const char *ptr = find_last_slash(in_path); if (ptr) ptr++; else ptr = in_path; /* In case of compression, we also have to consider paths like * /path/to/archive.7z#mygame.img * and * /path/to/archive.7z#folder/mygame.img * basename would be mygame.img in both cases */ #ifdef HAVE_COMPRESSION const char *ptr_bak = ptr; ptr = strchr(ptr_bak,'#'); if (ptr) ptr++; else ptr = ptr_bak; #endif rarch_assert(strlcpy(out, ptr, size) < size); }
static bool preprocess_image(void *data) { video4linux_t *v4l = (video4linux_t*)data; struct v4l2_buffer buf; memset(&buf, 0, sizeof(buf)); buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; buf.memory = V4L2_MEMORY_MMAP; if (xioctl(v4l->fd, VIDIOC_DQBUF, &buf) == -1) { switch (errno) { case EAGAIN: return false; default: RARCH_ERR("VIDIOC_DQBUF.\n"); return false; } } rarch_assert(buf.index < v4l->n_buffers); process_image(v4l, (const uint8_t*)v4l->buffers[buf.index].start); if (xioctl(v4l->fd, VIDIOC_QBUF, &buf) == -1) RARCH_ERR("VIDIOC_QBUF\n"); return true; }
/** * menu_init: * @data : Menu context handle. * * Create and initialize menu handle. * * Returns: menu handle on success, otherwise NULL. **/ void *menu_init(const void *data) { menu_handle_t *menu = NULL; menu_display_t *disp = NULL; menu_ctx_driver_t *menu_ctx = (menu_ctx_driver_t*)data; global_t *global = global_get_ptr(); settings_t *settings = config_get_ptr(); if (!menu_ctx) return NULL; if (!(menu = (menu_handle_t*)menu_ctx->init())) return NULL; strlcpy(settings->menu.driver, menu_ctx->ident, sizeof(settings->menu.driver)); if (menu_init_entries(&menu->entries) != 0) goto error; global->core_info_current = (core_info_t*)calloc(1, sizeof(core_info_t)); if (!global->core_info_current) goto error; #ifdef HAVE_SHADER_MANAGER menu->shader = (struct video_shader*)calloc(1, sizeof(struct video_shader)); if (!menu->shader) goto error; #endif menu->push_start_screen = settings->menu_show_start_screen; settings->menu_show_start_screen = false; menu_shader_manager_init(menu); if (!menu_display_init(menu)) goto error; disp = &menu->display; rarch_assert(disp->msg_queue = msg_queue_new(8)); menu_display_fb_set_dirty(); menu_driver_set_alive(); return menu; error: if (menu->entries.menu_list) menu_list_free(menu->entries.menu_list); menu->entries.menu_list = NULL; if (global->core_info_current) free(global->core_info_current); global->core_info_current = NULL; if (menu->shader) free(menu->shader); menu->shader = NULL; if (menu) free(menu); return NULL; }
/** * init_libretro_sym: * @type : Type of core to be loaded. * If CORE_TYPE_DUMMY, will * load dummy symbols. * * Initializes libretro symbols and * setups environment callback functions. **/ void init_libretro_sym(enum rarch_core_type type) { /* Guarantee that we can do "dirty" casting. * Every OS that this program supports should pass this. */ rarch_assert(sizeof(void*) == sizeof(void (*)(void))); load_symbols(type); }
/** * main_load_content: * @argc : Argument count. * @argv : Argument variable list. * @args : Arguments passed from callee. * @environ_get : Function passed for environment_get function. * @process_args : Function passed for process_args function. * * Loads content file and starts up RetroArch. * If no content file can be loaded, will start up RetroArch * as-is. * * Returns: false (0) if rarch_main_init failed, otherwise true (1). **/ bool main_load_content(int argc, char **argv, void *args, environment_get_t environ_get, process_args_t process_args) { unsigned i; bool retval = true; int ret = 0, rarch_argc = 0; char *rarch_argv[MAX_ARGS] = {NULL}; char *argv_copy [MAX_ARGS] = {NULL}; char **rarch_argv_ptr = (char**)argv; int *rarch_argc_ptr = (int*)&argc; global_t *global = global_get_ptr(); struct rarch_main_wrap *wrap_args = (struct rarch_main_wrap*) calloc(1, sizeof(*wrap_args)); if (!wrap_args) return false; (void)rarch_argc_ptr; (void)rarch_argv_ptr; (void)ret; rarch_assert(wrap_args); if (environ_get) environ_get(rarch_argc_ptr, rarch_argv_ptr, args, wrap_args); check_defaults_dirs(); if (wrap_args->touched) { rarch_main_init_wrap(wrap_args, &rarch_argc, rarch_argv); memcpy(argv_copy, rarch_argv, sizeof(rarch_argv)); rarch_argv_ptr = (char**)rarch_argv; rarch_argc_ptr = (int*)&rarch_argc; } if (global->main_is_init) rarch_main_deinit(); if ((ret = rarch_main_init(*rarch_argc_ptr, rarch_argv_ptr))) { retval = false; goto error; } event_command(EVENT_CMD_RESUME); if (process_args) process_args(rarch_argc_ptr, rarch_argv_ptr); error: for (i = 0; i < ARRAY_SIZE(argv_copy); i++) free(argv_copy[i]); free(wrap_args); return retval; }
void rarch_main_data_http_init_msg_queue(void) { http_handle_t *http = (http_handle_t*)http_ptr; if (!http) return; if (!http->msg_queue) rarch_assert(http->msg_queue = msg_queue_new(8)); }
void fill_pathname_application_path(char *buf, size_t size) { size_t i; (void)i; if (!size) return; #ifdef _WIN32 DWORD ret = GetModuleFileName(GetModuleHandle(NULL), buf, size - 1); buf[ret] = '\0'; #elif defined(__APPLE__) CFBundleRef bundle = CFBundleGetMainBundle(); if (bundle) { CFURLRef bundle_url = CFBundleCopyBundleURL(bundle); CFStringRef bundle_path = CFURLCopyPath(bundle_url); CFStringGetCString(bundle_path, buf, size, kCFStringEncodingUTF8); CFRelease(bundle_path); CFRelease(bundle_url); rarch_assert(strlcat(buf, "nobin", size) < size); return; } #elif defined(__HAIKU__) image_info info; int32 cookie = 0; while (get_next_image_info(0, &cookie, &info) == B_OK) { if (info.type == B_APP_IMAGE) { strlcpy(buf, info.name, size); return; } } #else *buf = '\0'; pid_t pid = getpid(); char link_path[PATH_MAX]; /* Linux, BSD and Solaris paths. Not standardized. */ static const char *exts[] = { "exe", "file", "path/a.out" }; for (i = 0; i < ARRAY_SIZE(exts); i++) { snprintf(link_path, sizeof(link_path), "/proc/%u/%s", (unsigned)pid, exts[i]); ssize_t ret = readlink(link_path, buf, size - 1); if (ret >= 0) { buf[ret] = '\0'; return; } } RARCH_ERR("Cannot resolve application path! This should not happen.\n"); #endif }
static gfx_ctx_proc_t gfx_ctx_qnx_get_proc_address(const char *symbol) { rarch_assert(sizeof(void*) == sizeof(void (*)(void))); gfx_ctx_proc_t ret; void *sym__ = eglGetProcAddress(symbol); memcpy(&ret, &sym__, sizeof(void*)); return ret; }
void fill_pathname_expand_special(char *out_path, const char *in_path, size_t size) { #if !defined(RARCH_CONSOLE) if (*in_path == '~') { const char *home = getenv("HOME"); if (home) { size_t src_size = strlcpy(out_path, home, size); rarch_assert(src_size < size); out_path += src_size; size -= src_size; in_path++; } } else if ((in_path[0] == ':') && #ifdef _WIN32 ((in_path[1] == '/') || (in_path[1] == '\\')) #else (in_path[1] == '/') #endif ) { size_t src_size; char application_dir[PATH_MAX_LENGTH] = {0}; fill_pathname_application_path(application_dir, sizeof(application_dir)); path_basedir(application_dir); src_size = strlcpy(out_path, application_dir, size); rarch_assert(src_size < size); out_path += src_size; size -= src_size; in_path += 2; } #endif rarch_assert(strlcpy(out_path, in_path, size) < size); }
static void gl_glsl_reset_attrib(glsl_shader_data_t *glsl) { unsigned i; /* Add sanity check that we did not overflow. */ rarch_assert(glsl->gl_attrib_index <= ARRAY_SIZE(glsl->gl_attribs)); for (i = 0; i < glsl->gl_attrib_index; i++) glDisableVertexAttribArray(glsl->gl_attribs[i]); glsl->gl_attrib_index = 0; }
static void shuffle_block(char **begin, char **last, char **end) { ptrdiff_t len = last - begin; const char **tmp = (const char**)calloc(len, sizeof(const char*)); rarch_assert(tmp); memcpy(tmp, begin, len * sizeof(const char*)); memmove(begin, last, (end - last) * sizeof(const char*)); memcpy(end - len, tmp, len * sizeof(const char*)); free(tmp); }
/** * rarch_defer_core: * @core_info : Core info list handle. * @dir : Directory. Gets joined with @path. * @path : Path. Gets joined with @dir. * @menu_label : Label identifier of menu setting. * @s : Deferred core path. Will be filled in * by function. * @len : Size of @s. * * Gets deferred core. * * Returns: 0 if there are multiple deferred cores and a * selection needs to be made from a list, otherwise * returns -1 and fills in @s with path to core. **/ int rarch_defer_core(core_info_list_t *core_info, const char *dir, const char *path, const char *menu_label, char *s, size_t len) { char new_core_path[PATH_MAX_LENGTH] = {0}; const core_info_t *info = NULL; size_t supported = 0; settings_t *settings = config_get_ptr(); global_t *global = global_get_ptr(); uint32_t menu_label_hash = msg_hash_calculate(menu_label); fill_pathname_join(s, dir, path, len); #ifdef HAVE_COMPRESSION if (path_is_compressed_file(dir)) { /* In case of a compressed archive, we have to join with a hash */ /* We are going to write at the position of dir: */ rarch_assert(strlen(dir) < strlen(s)); s[strlen(dir)] = '#'; } #endif if (core_info) core_info_list_get_supported_cores(core_info, s, &info, &supported); if (menu_label_hash == MENU_LABEL_LOAD_CONTENT) { info = (const core_info_t*)&global->core_info.current; if (info) { strlcpy(new_core_path, info->path, sizeof(new_core_path)); supported = 1; } } else strlcpy(new_core_path, info->path, sizeof(new_core_path)); /* There are multiple deferred cores and a * selection needs to be made from a list, return 0. */ if (supported != 1) return 0; strlcpy(global->path.fullpath, s, sizeof(global->path.fullpath)); if (path_file_exists(new_core_path)) strlcpy(settings->libretro, new_core_path, sizeof(settings->libretro)); return -1; }
static void gl_cg_reset_attrib(cg_shader_data_t *cg) { unsigned i; if (!cg) return; /* Add sanity check that we did not overflow. */ rarch_assert(cg->cg_attrib_idx <= ARRAY_SIZE(cg->cg_attribs)); for (i = 0; i < cg->cg_attrib_idx; i++) cgGLDisableClientState(cg->cg_attribs[i]); cg->cg_attrib_idx = 0; }
static void set_special_paths(char **argv, unsigned num_content) { unsigned i; union string_list_elem_attr attr; global_t *global = global_get_ptr(); settings_t *settings = config_get_ptr(); /* First content file is the significant one. */ set_basename(argv[0]); global->subsystem_fullpaths = string_list_new(); rarch_assert(global->subsystem_fullpaths); attr.i = 0; for (i = 0; i < num_content; i++) string_list_append(global->subsystem_fullpaths, argv[i], attr); /* We defer SRAM path updates until we can resolve it. * It is more complicated for special content types. */ if (!global->has_set.state_path) fill_pathname_noext(global->name.savestate, global->name.base, ".state", sizeof(global->name.savestate)); if (path_is_directory(global->name.savestate)) { fill_pathname_dir(global->name.savestate, global->name.base, ".state", sizeof(global->name.savestate)); RARCH_LOG("%s \"%s\".\n", msg_hash_to_str(MSG_REDIRECTING_SAVESTATE_TO), global->name.savestate); } /* If this is already set, * do not overwrite it as this was initialized before in * a menu or otherwise. */ if (settings->system_directory[0] == '\0') { RARCH_WARN("SYSTEM DIR is empty, assume CONTENT DIR %s\n",argv[0]); /*fill_pathname_basedir(settings->system_directory, argv[0], sizeof(settings->system_directory));*/ } }
static void psp_set_texture_frame(void *data, const void *frame, bool rgb32, unsigned width, unsigned height, float alpha) { psp1_video_t *psp = (psp1_video_t*)data; (void) rgb32; (void) alpha; #ifdef DEBUG /* psp->menu.frame buffer size is (480 * 272)*2 Bytes */ rarch_assert((width*height) < (480 * 272)); #endif psp_set_screen_coords(psp->menu.frame_coords, 0, 0, SCEGU_SCR_WIDTH, SCEGU_SCR_HEIGHT, 0); psp_set_tex_coords(psp->menu.frame_coords, width, height); sceKernelDcacheWritebackRange(frame, width * height * 2); sceGuStart(GU_DIRECT, psp->main_dList); sceGuCopyImage(GU_PSM_4444, 0, 0, width, height, width, (void*)frame, 0, 0, width, psp->menu.frame); sceGuFinish(); sceGuStart(GU_SEND, psp->menu.dList); sceGuTexMode(GU_PSM_4444, 0, 0, GU_FALSE); sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGB); sceGuTexFilter(GU_LINEAR, GU_LINEAR); sceGuTexImage(0, next_pow2(width), next_pow2(height), width, psp->menu.frame); sceGuEnable(GU_BLEND); #if 0 /* default blending */ sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0); #endif sceGuBlendFunc(GU_ADD, GU_FIX, GU_FIX, 0xF0F0F0F0, 0x0F0F0F0F); ; sceGuDrawArray(GU_SPRITES, GU_TEXTURE_32BITF | GU_VERTEX_32BITF | GU_TRANSFORM_2D, PSP_FRAME_VERTEX_COUNT, NULL, psp->menu.frame_coords); sceGuFinish(); }