int main(int argc, const char **argv) { unsigned char proxy_header[MAX_HEADER_SIZE + 1]; ssize_t n = 0; int address_len = 0; if (argc == 1) n = read(STDIN_FILENO, proxy_header, MAX_HEADER_SIZE); else if (argc == 2) n = read_from_socket(argv[1], proxy_header, MAX_HEADER_SIZE); else { fprintf(stderr, "Usage: parse_proxy_v2 [port]\n"); return (1); } if (n < 16) { printf("ERROR:\tread too few bytes.\n"); return (1); } proxy_header[n] = '\0'; if (strncmp("PROXY TCP", (char *)proxy_header, 9) == 0) { /* PROXY version 1 over TCP */ fprintf(stdout, "ERROR:\tPROXY v1 parsing not supported in this tool.\n"); return (1); } else if (memcmp(PROXY_V2_HEADER, proxy_header, 12) != 0) { printf("ERROR:\tNot a valid PROXY header\n"); return (1); } printf("PROXY v2 detected.\n"); switch (proxy_header[12]) { case 0x20: printf("ERROR:\tLOCAL connection\n"); return (1); case 0x21: printf("Connection:\tPROXYed connection detected\n"); break; default: printf("ERROR:\t13th byte has illegal value %d\n", (int)proxy_header[12]); return (1); } switch (proxy_header[13]) { case 0x00: printf("ERROR:\tProtocol:\tUnspecified/unsupported\n"); return (1); case 0x11: printf("Protocol:\tTCP over IPv4\n"); address_len = 12; break; case 0x12: printf("Protocol:\tUDP over IPv4\n"); printf("ERROR:\tProtocol unsupported in hitch seen\n"); address_len = 12; break; case 0x21: printf("Protocol:\tTCP over IPv6\n"); address_len = 36; break; case 0x22: printf("Protocol:\tUDP over IPv6\n"); printf("ERROR:\tProtocol unsupported in hitch\n"); address_len = 36; break; case 0x31: printf("Protocol:\tUNIX stream\n"); address_len = 216; break; case 0x32: printf("Protocol:\tUNIX datagram\n"); printf("ERROR:\tProtocol unsupported in hitch\n"); address_len = 216; break; default: printf("ERROR:\t14th byte has illegal value %d\n", (int)proxy_header[13]); return (1); } int additional_len = (proxy_header[14] << 8) + proxy_header[15]; if (additional_len < address_len) { printf("ERROR:\tThe the total header length %d does" " not leave room for the addresses\n", additional_len + 16); return (1); } if (additional_len + 16 > n) { printf("ERROR:\tToo few bytes was read; %zd\n", n); return (1); } if (address_len == 12) print_addr_with_ports(AF_INET, 4, proxy_header + 16); else if (address_len == 36) print_addr_with_ports(AF_INET6, 16, proxy_header + 16); else { printf("ERROR:\tPrinting of UNIX socket addresses" " not implemented.\n"); } if (address_len < additional_len) return print_extensions(proxy_header + 16 + address_len, additional_len - address_len); return (0); }
static int do_cli(int argc, char **argv) /* {{{ */ { int c; zend_file_handle file_handle; int behavior = PHP_MODE_STANDARD; char *reflection_what = NULL; volatile int request_started = 0; volatile int exit_status = 0; char *php_optarg = NULL, *orig_optarg = NULL; int php_optind = 1, orig_optind = 1; char *exec_direct=NULL, *exec_run=NULL, *exec_begin=NULL, *exec_end=NULL; char *arg_free=NULL, **arg_excp=&arg_free; char *script_file=NULL, *translated_path = NULL; int interactive=0; int lineno = 0; const char *param_error=NULL; int hide_argv = 0; zend_try { CG(in_compilation) = 0; /* not initialized but needed for several options */ while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2)) != -1) { switch (c) { case 'i': /* php info & quit */ if (php_request_startup()==FAILURE) { goto err; } request_started = 1; php_print_info(0xFFFFFFFF); php_output_end_all(); exit_status = (c == '?' && argc > 1 && !strchr(argv[1], c)); goto out; case 'v': /* show php version & quit */ php_printf("PHP %s (%s) (built: %s %s) ( %s)\nCopyright (c) 1997-2016 The PHP Group\n%s", PHP_VERSION, cli_sapi_module.name, __DATE__, __TIME__, #if ZTS "ZTS " #else "NTS " #endif #if ZEND_DEBUG "DEBUG " #endif #ifdef HAVE_GCOV "GCOV " #endif , get_zend_version() ); sapi_deactivate(); goto out; case 'm': /* list compiled in modules */ if (php_request_startup()==FAILURE) { goto err; } request_started = 1; php_printf("[PHP Modules]\n"); print_modules(); php_printf("\n[Zend Modules]\n"); print_extensions(); php_printf("\n"); php_output_end_all(); exit_status=0; goto out; default: break; } } /* Set some CLI defaults */ SG(options) |= SAPI_OPTION_NO_CHDIR; php_optind = orig_optind; php_optarg = orig_optarg; while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2)) != -1) { switch (c) { case 'a': /* interactive mode */ if (!interactive) { if (behavior != PHP_MODE_STANDARD) { param_error = param_mode_conflict; break; } interactive=1; } break; case 'C': /* don't chdir to the script directory */ /* This is default so NOP */ break; case 'F': if (behavior == PHP_MODE_PROCESS_STDIN) { if (exec_run || script_file) { param_error = "You can use -R or -F only once.\n"; break; } } else if (behavior != PHP_MODE_STANDARD) { param_error = param_mode_conflict; break; } behavior=PHP_MODE_PROCESS_STDIN; script_file = php_optarg; break; case 'f': /* parse file */ if (behavior == PHP_MODE_CLI_DIRECT || behavior == PHP_MODE_PROCESS_STDIN) { param_error = param_mode_conflict; break; } else if (script_file) { param_error = "You can use -f only once.\n"; break; } script_file = php_optarg; break; case 'l': /* syntax check mode */ if (behavior != PHP_MODE_STANDARD) { break; } behavior=PHP_MODE_LINT; break; case 'q': /* do not generate HTTP headers */ /* This is default so NOP */ break; case 'r': /* run code from command line */ if (behavior == PHP_MODE_CLI_DIRECT) { if (exec_direct || script_file) { param_error = "You can use -r only once.\n"; break; } } else if (behavior != PHP_MODE_STANDARD || interactive) { param_error = param_mode_conflict; break; } behavior=PHP_MODE_CLI_DIRECT; exec_direct=php_optarg; break; case 'R': if (behavior == PHP_MODE_PROCESS_STDIN) { if (exec_run || script_file) { param_error = "You can use -R or -F only once.\n"; break; } } else if (behavior != PHP_MODE_STANDARD) { param_error = param_mode_conflict; break; } behavior=PHP_MODE_PROCESS_STDIN; exec_run=php_optarg; break; case 'B': if (behavior == PHP_MODE_PROCESS_STDIN) { if (exec_begin) { param_error = "You can use -B only once.\n"; break; } } else if (behavior != PHP_MODE_STANDARD || interactive) { param_error = param_mode_conflict; break; } behavior=PHP_MODE_PROCESS_STDIN; exec_begin=php_optarg; break; case 'E': if (behavior == PHP_MODE_PROCESS_STDIN) { if (exec_end) { param_error = "You can use -E only once.\n"; break; } } else if (behavior != PHP_MODE_STANDARD || interactive) { param_error = param_mode_conflict; break; } behavior=PHP_MODE_PROCESS_STDIN; exec_end=php_optarg; break; case 's': /* generate highlighted HTML from source */ if (behavior == PHP_MODE_CLI_DIRECT || behavior == PHP_MODE_PROCESS_STDIN) { param_error = "Source highlighting only works for files.\n"; break; } behavior=PHP_MODE_HIGHLIGHT; break; case 'w': if (behavior == PHP_MODE_CLI_DIRECT || behavior == PHP_MODE_PROCESS_STDIN) { param_error = "Source stripping only works for files.\n"; break; } behavior=PHP_MODE_STRIP; break; case 'z': /* load extension file */ zend_load_extension(php_optarg); break; case 'H': hide_argv = 1; break; case 10: behavior=PHP_MODE_REFLECTION_FUNCTION; reflection_what = php_optarg; break; case 11: behavior=PHP_MODE_REFLECTION_CLASS; reflection_what = php_optarg; break; case 12: behavior=PHP_MODE_REFLECTION_EXTENSION; reflection_what = php_optarg; break; case 13: behavior=PHP_MODE_REFLECTION_ZEND_EXTENSION; reflection_what = php_optarg; break; case 14: behavior=PHP_MODE_REFLECTION_EXT_INFO; reflection_what = php_optarg; break; case 15: behavior = PHP_MODE_SHOW_INI_CONFIG; break; default: break; } } if (param_error) { PUTS(param_error); exit_status=1; goto err; } if (interactive) { #if (HAVE_LIBREADLINE || HAVE_LIBEDIT) && !defined(COMPILE_DL_READLINE) printf("Interactive shell\n\n"); #else printf("Interactive mode enabled\n\n"); #endif fflush(stdout); } /* only set script_file if not set already and not in direct mode and not at end of parameter list */ if (argc > php_optind && !script_file && behavior!=PHP_MODE_CLI_DIRECT && behavior!=PHP_MODE_PROCESS_STDIN && strcmp(argv[php_optind-1],"--")) { script_file=argv[php_optind]; php_optind++; } if (script_file) { if (cli_seek_file_begin(&file_handle, script_file, &lineno) != SUCCESS) { goto err; } else { char real_path[MAXPATHLEN]; if (VCWD_REALPATH(script_file, real_path)) { translated_path = strdup(real_path); } script_filename = script_file; } } else { /* We could handle PHP_MODE_PROCESS_STDIN in a different manner */ /* here but this would make things only more complicated. And it */ /* is consitent with the way -R works where the stdin file handle*/ /* is also accessible. */ file_handle.filename = "-"; file_handle.handle.fp = stdin; } file_handle.type = ZEND_HANDLE_FP; file_handle.opened_path = NULL; file_handle.free_filename = 0; php_self = (char*)file_handle.filename; /* before registering argv to module exchange the *new* argv[0] */ /* we can achieve this without allocating more memory */ SG(request_info).argc=argc-php_optind+1; arg_excp = argv+php_optind-1; arg_free = argv[php_optind-1]; SG(request_info).path_translated = translated_path? translated_path: (char*)file_handle.filename; argv[php_optind-1] = (char*)file_handle.filename; SG(request_info).argv=argv+php_optind-1; if (php_request_startup()==FAILURE) { *arg_excp = arg_free; fclose(file_handle.handle.fp); PUTS("Could not startup.\n"); goto err; } request_started = 1; CG(start_lineno) = lineno; *arg_excp = arg_free; /* reconstuct argv */ if (hide_argv) { int i; for (i = 1; i < argc; i++) { memset(argv[i], 0, strlen(argv[i])); } } zend_is_auto_global_str(ZEND_STRL("_SERVER")); PG(during_request_startup) = 0; switch (behavior) { case PHP_MODE_STANDARD: if (strcmp(file_handle.filename, "-")) { cli_register_file_handles(); } if (interactive && cli_shell_callbacks.cli_shell_run) { exit_status = cli_shell_callbacks.cli_shell_run(); } else { php_execute_script(&file_handle); exit_status = EG(exit_status); } break; case PHP_MODE_LINT: exit_status = php_lint_script(&file_handle); if (exit_status==SUCCESS) { zend_printf("No syntax errors detected in %s\n", file_handle.filename); } else { zend_printf("Errors parsing %s\n", file_handle.filename); } break; case PHP_MODE_STRIP: if (open_file_for_scanning(&file_handle)==SUCCESS) { zend_strip(); } goto out; break; case PHP_MODE_HIGHLIGHT: { zend_syntax_highlighter_ini syntax_highlighter_ini; if (open_file_for_scanning(&file_handle)==SUCCESS) { php_get_highlight_struct(&syntax_highlighter_ini); zend_highlight(&syntax_highlighter_ini); } goto out; } break; case PHP_MODE_CLI_DIRECT: cli_register_file_handles(); if (zend_eval_string_ex(exec_direct, NULL, "Command line code", 1) == FAILURE) { exit_status=254; } break; case PHP_MODE_PROCESS_STDIN: { char *input; size_t len, index = 0; zval argn, argi; cli_register_file_handles(); if (exec_begin && zend_eval_string_ex(exec_begin, NULL, "Command line begin code", 1) == FAILURE) { exit_status=254; } while (exit_status == SUCCESS && (input=php_stream_gets(s_in_process, NULL, 0)) != NULL) { len = strlen(input); while (len > 0 && len-- && (input[len]=='\n' || input[len]=='\r')) { input[len] = '\0'; } ZVAL_STRINGL(&argn, input, len + 1); zend_hash_str_update(&EG(symbol_table), "argn", sizeof("argn")-1, &argn); ZVAL_LONG(&argi, ++index); zend_hash_str_update(&EG(symbol_table), "argi", sizeof("argi")-1, &argi); if (exec_run) { if (zend_eval_string_ex(exec_run, NULL, "Command line run code", 1) == FAILURE) { exit_status=254; } } else { if (script_file) { if (cli_seek_file_begin(&file_handle, script_file, &lineno) != SUCCESS) { exit_status = 1; } else { CG(start_lineno) = lineno; php_execute_script(&file_handle); exit_status = EG(exit_status); } } } efree(input); } if (exec_end && zend_eval_string_ex(exec_end, NULL, "Command line end code", 1) == FAILURE) { exit_status=254; } break; } case PHP_MODE_REFLECTION_FUNCTION: case PHP_MODE_REFLECTION_CLASS: case PHP_MODE_REFLECTION_EXTENSION: case PHP_MODE_REFLECTION_ZEND_EXTENSION: { zend_class_entry *pce = NULL; zval arg, ref; zend_execute_data execute_data; switch (behavior) { default: break; case PHP_MODE_REFLECTION_FUNCTION: if (strstr(reflection_what, "::")) { pce = reflection_method_ptr; } else { pce = reflection_function_ptr; } break; case PHP_MODE_REFLECTION_CLASS: pce = reflection_class_ptr; break; case PHP_MODE_REFLECTION_EXTENSION: pce = reflection_extension_ptr; break; case PHP_MODE_REFLECTION_ZEND_EXTENSION: pce = reflection_zend_extension_ptr; break; } ZVAL_STRING(&arg, reflection_what); object_init_ex(&ref, pce); memset(&execute_data, 0, sizeof(zend_execute_data)); EG(current_execute_data) = &execute_data; zend_call_method_with_1_params(&ref, pce, &pce->constructor, "__construct", NULL, &arg); if (EG(exception)) { zval tmp, *msg, rv; ZVAL_OBJ(&tmp, EG(exception)); msg = zend_read_property(zend_ce_exception, &tmp, "message", sizeof("message")-1, 0, &rv); zend_printf("Exception: %s\n", Z_STRVAL_P(msg)); zval_ptr_dtor(&tmp); EG(exception) = NULL; } else { zend_call_method_with_1_params(NULL, reflection_ptr, NULL, "export", NULL, &ref); } zval_ptr_dtor(&ref); zval_ptr_dtor(&arg); break; } case PHP_MODE_REFLECTION_EXT_INFO: { int len = (int)strlen(reflection_what); char *lcname = zend_str_tolower_dup(reflection_what, len); zend_module_entry *module; if ((module = zend_hash_str_find_ptr(&module_registry, lcname, len)) == NULL) { if (!strcmp(reflection_what, "main")) { display_ini_entries(NULL); } else { zend_printf("Extension '%s' not present.\n", reflection_what); exit_status = 1; } } else { php_info_print_module(module); } efree(lcname); break; } case PHP_MODE_SHOW_INI_CONFIG: { zend_printf("Configuration File (php.ini) Path: %s\n", PHP_CONFIG_FILE_PATH); zend_printf("Loaded Configuration File: %s\n", php_ini_opened_path ? php_ini_opened_path : "(none)"); zend_printf("Scan for additional .ini files in: %s\n", php_ini_scanned_path ? php_ini_scanned_path : "(none)"); zend_printf("Additional .ini files parsed: %s\n", php_ini_scanned_files ? php_ini_scanned_files : "(none)"); break; } } } zend_end_try(); out: if (request_started) { php_request_shutdown((void *) 0); } if (translated_path) { free(translated_path); } if (exit_status == 0) { exit_status = EG(exit_status); } return exit_status; err: sapi_deactivate(); zend_ini_deactivate(); exit_status = 1; goto out; }
/* _al_ogl_manage_extensions: * This functions fills the extensions API table and extension list * structures and displays on the log file which extensions are available. */ void _al_ogl_manage_extensions(ALLEGRO_DISPLAY *gl_disp) { //const GLubyte *buf; #if defined ALLEGRO_MACOSX CFURLRef bundle_url; #endif ALLEGRO_OGL_EXT_API *ext_api; ALLEGRO_OGL_EXT_LIST *ext_list; /* Print out OpenGL extensions * We should use glGetStringi(GL_EXTENSIONS, i) for OpenGL 3.0+ * but it doesn't seem to work until later. */ if (!_al_ogl_version_3_only(gl_disp->flags)) { ALLEGRO_DEBUG("OpenGL Extensions:\n"); print_extensions((char const *)glGetString(GL_EXTENSIONS)); } /* Print out GLU version */ //buf = gluGetString(GLU_VERSION); //ALLEGRO_INFO("GLU Version : %s\n", buf); #ifdef ALLEGRO_HAVE_DYNAMIC_LINK /* Get glXGetProcAddress entry */ __libgl_handle = dlopen("libGL.so", RTLD_LAZY); if (__libgl_handle) { alXGetProcAddress = (GLXGETPROCADDRESSARBPROC) dlsym(__libgl_handle, "glXGetProcAddressARB"); if (!alXGetProcAddress) { alXGetProcAddress = (GLXGETPROCADDRESSARBPROC) dlsym(__libgl_handle, "glXGetProcAddress"); if (!alXGetProcAddress) { alXGetProcAddress = (GLXGETPROCADDRESSARBPROC) dlsym(__libgl_handle, "eglGetProcAddress"); } } } else { ALLEGRO_WARN("Failed to dlopen libGL.so : %s\n", dlerror()); } ALLEGRO_INFO("glXGetProcAddress Extension: %s\n", alXGetProcAddress ? "Supported" : "Unsupported"); #elif defined ALLEGRO_UNIX #ifdef ALLEGROGL_GLXGETPROCADDRESSARB ALLEGRO_INFO("glXGetProcAddressARB Extension: supported\n"); #else ALLEGRO_INFO("glXGetProcAddress Extension: supported\n"); #endif #endif #ifdef ALLEGRO_MACOSX bundle_url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, CFSTR ("/System/Library/Frameworks/OpenGL.framework"), kCFURLPOSIXPathStyle, true); opengl_bundle_ref = CFBundleCreate(kCFAllocatorDefault, bundle_url); CFRelease(bundle_url); #endif #if defined ALLEGRO_UNIX && !defined ALLEGRO_EXCLUDE_GLX ALLEGRO_DEBUG("GLX Extensions:\n"); ALLEGRO_SYSTEM_XGLX *glx_sys = (void*)al_get_system_driver(); ALLEGRO_DISPLAY_XGLX *glx_disp = (void *)gl_disp; char const *ext = glXQueryExtensionsString( glx_sys->gfxdisplay, glx_disp->xscreen); if (!ext) { /* work around driver bugs? */ ext = ""; } print_extensions(ext); #endif fill_in_info_struct(glGetString(GL_RENDERER), &(gl_disp->ogl_extras->ogl_info)); /* Create & load extension API table */ ext_api = create_extension_api_table(); load_extensions(ext_api); gl_disp->ogl_extras->extension_api = ext_api; #if !defined ALLEGRO_IPHONE && !defined ALLEGRO_ANDROID /* Need that symbol already so can't wait until it is assigned later. */ glGetStringi = ext_api->GetStringi; if (_al_ogl_version_3_only(gl_disp->flags)) { ALLEGRO_DEBUG("OpenGL Extensions:\n"); print_extensions_3_0(); } #endif /* Create the list of supported extensions. */ ext_list = create_extension_list(); gl_disp->ogl_extras->extension_list = ext_list; /* Fill the list. */ #define AGL_EXT(name, ver) { \ ext_list->ALLEGRO_GL_##name = \ _ogl_is_extension_with_version_supported("GL_" #name, gl_disp, \ _ALLEGRO_OPENGL_VERSION_##ver); \ } #include "allegro5/opengl/GLext/gl_ext_list.h" #undef AGL_EXT #ifdef ALLEGRO_UNIX #define AGL_EXT(name, ver) { \ ext_list->ALLEGRO_GLX_##name = \ _ogl_is_extension_with_version_supported("GLX_" #name, gl_disp, \ _ALLEGRO_OPENGL_VERSION_##ver); \ } #include "allegro5/opengl/GLext/glx_ext_list.h" #undef AGL_EXT #elif defined ALLEGRO_WINDOWS #define AGL_EXT(name, ver) { \ ext_list->ALLEGRO_WGL_##name = \ _ogl_is_extension_with_version_supported("WGL_" #name, gl_disp, \ _ALLEGRO_OPENGL_VERSION_##ver); \ } #include "allegro5/opengl/GLext/wgl_ext_list.h" #undef AGL_EXT #endif /* TODO: use these somewhere */ #if 0 for (i = 0; i < 5; i++) { __allegro_gl_texture_read_format[i] = -1; __allegro_gl_texture_components[i] = GL_RGB; } __allegro_gl_texture_read_format[3] = GL_UNSIGNED_BYTE; __allegro_gl_texture_read_format[4] = GL_UNSIGNED_BYTE; __allegro_gl_texture_components[4] = GL_RGBA; #endif /* #if 0 */ /* Get max texture size */ glGetIntegerv(GL_MAX_TEXTURE_SIZE, (GLint *) & gl_disp->ogl_extras->ogl_info.max_texture_size); /* Note: Voodoo (even V5) don't seem to correctly support * packed pixel formats. Disabling them for those cards. */ ext_list->ALLEGRO_GL_EXT_packed_pixels &= !gl_disp->ogl_extras->ogl_info.is_voodoo; if (ext_list->ALLEGRO_GL_EXT_packed_pixels) { ALLEGRO_INFO("Packed Pixels formats available\n"); /* XXX On NV cards, we want to use BGRA instead of RGBA for speed */ /* Fills the __allegro_gl_texture_format array */ /* TODO: use these somewhere */ #if 0 __allegro_gl_texture_read_format[0] = GL_UNSIGNED_BYTE_3_3_2; __allegro_gl_texture_read_format[1] = GL_UNSIGNED_SHORT_5_5_5_1; __allegro_gl_texture_read_format[2] = GL_UNSIGNED_SHORT_5_6_5; #endif /* #if 0 */ } /* NVidia and ATI cards expose OpenGL 2.0 but often don't accelerate * non-power-of-2 textures. This check is how you verify that NP2 * textures are hardware accelerated or not. * We should clobber the NPOT support if it's not accelerated. */ { const char *vendor = (const char *)glGetString(GL_VENDOR); if (strstr(vendor, "NVIDIA Corporation")) { if (!ext_list->ALLEGRO_GL_NV_fragment_program2 || !ext_list->ALLEGRO_GL_NV_vertex_program3) { ext_list->ALLEGRO_GL_ARB_texture_non_power_of_two = 0; } } else if (strstr(vendor, "ATI Technologies")) { if (_al_ogl_version_3_only(gl_disp->flags)) { /* Assume okay. */ } else if (!strstr((const char *)glGetString(GL_EXTENSIONS), "GL_ARB_texture_non_power_of_two") && gl_disp->ogl_extras->ogl_info.version >= _ALLEGRO_OPENGL_VERSION_2_0) { ext_list->ALLEGRO_GL_ARB_texture_non_power_of_two = 0; } } } { int *s = gl_disp->extra_settings.settings; glGetIntegerv(GL_MAX_TEXTURE_SIZE, s + ALLEGRO_MAX_BITMAP_SIZE); if (gl_disp->ogl_extras->ogl_info.version >= _ALLEGRO_OPENGL_VERSION_2_0) s[ALLEGRO_SUPPORT_SEPARATE_ALPHA] = 1; s[ALLEGRO_SUPPORT_NPOT_BITMAP] = ext_list->ALLEGRO_GL_ARB_texture_non_power_of_two || ext_list->ALLEGRO_GL_OES_texture_npot; ALLEGRO_INFO("Use of non-power-of-two textures %s.\n", s[ALLEGRO_SUPPORT_NPOT_BITMAP] ? "enabled" : "disabled"); #if defined ALLEGRO_IPHONE || defined ALLEGRO_ANDROID if (gl_disp->flags & ALLEGRO_USE_PROGRAMMABLE_PIPELINE) { s[ALLEGRO_CAN_DRAW_INTO_BITMAP] = true; } else { s[ALLEGRO_CAN_DRAW_INTO_BITMAP] = ext_list->ALLEGRO_GL_OES_framebuffer_object; } ALLEGRO_INFO("Use of FBO to draw to textures %s.\n", s[ALLEGRO_CAN_DRAW_INTO_BITMAP] ? "enabled" : "disabled"); #else s[ALLEGRO_CAN_DRAW_INTO_BITMAP] = ext_list->ALLEGRO_GL_EXT_framebuffer_object; ALLEGRO_INFO("Use of FBO to draw to textures %s.\n", s[ALLEGRO_CAN_DRAW_INTO_BITMAP] ? "enabled" : "disabled"); #endif } }