HRESULT create_vbdisp(const class_desc_t *desc, vbdisp_t **ret)
{
vbdisp_t *vbdisp;
HRESULT hres = S_OK;
vbdisp = heap_alloc_zero( FIELD_OFFSET( vbdisp_t, props[desc->prop_cnt] ));
if(!vbdisp)
return E_OUTOFMEMORY;
vbdisp->IDispatchEx_iface.lpVtbl = &DispatchExVtbl;
vbdisp->ref = 1;
vbdisp->desc = desc;
list_add_tail(&desc->ctx->objects, &vbdisp->entry);
if(desc->array_cnt) {
vbdisp->arrays = heap_alloc_zero(desc->array_cnt * sizeof(*vbdisp->arrays));
if(vbdisp->arrays) {
unsigned i, j;
for(i=0; i < desc->array_cnt; i++) {
if(!desc->array_descs[i].dim_cnt)
continue;
vbdisp->arrays[i] = SafeArrayCreate(VT_VARIANT, desc->array_descs[i].dim_cnt, desc->array_descs[i].bounds);
if(!vbdisp->arrays[i]) {
hres = E_OUTOFMEMORY;
break;
}
}
if(SUCCEEDED(hres)) {
for(i=0, j=0; i < desc->prop_cnt; i++) {
if(desc->props[i].is_array) {
V_VT(vbdisp->props+i) = VT_ARRAY|VT_BYREF|VT_VARIANT;
V_ARRAYREF(vbdisp->props+i) = vbdisp->arrays + j++;
}
}
}
}else {
hres = E_OUTOFMEMORY;
}
}
if(SUCCEEDED(hres) && desc->class_initialize_id) {
DISPPARAMS dp = {0};
hres = exec_script(desc->ctx, desc->funcs[desc->class_initialize_id].entries[VBDISP_CALLGET],
vbdisp, &dp, NULL);
}
if(FAILED(hres)) {
IDispatchEx_Release(&vbdisp->IDispatchEx_iface);
return hres;
}
*ret = vbdisp;
return S_OK;
}
void exec_setup_scripts()
{
/* Workaround to prevent hime-setup segfault, when hime/config/ is not exist.
*/
struct passwd *pw = getpwuid(getuid());
char hime_conf_dir[512];
g_snprintf(hime_conf_dir, sizeof(hime_conf_dir), "mkdir -p %s/.config/hime/config", pw->pw_dir);
dbg("do %s\n", hime_conf_dir);
system(hime_conf_dir);
exec_script("hime-user-setup "HIME_TABLE_DIR" "HIME_BIN_DIR);
}
static int
run_bootmenu(void) {
time_t start = time(NULL);
LOGI("Starting bootmenu on %s", ctime(&start));
if (bypass_check()) {
int status = INSTALL_SUCCESS;
exec_script(FILE_PRE_MENU, DISABLE);
led_alert("blue", ENABLE);
status = wait_key(KEY_VOLUMEDOWN);
if (status != INSTALL_ERROR) {
int mode = get_bootmode();
switch (mode) {
case MODE_2NDINIT:
led_alert("blue", DISABLE);
led_alert("green", ENABLE);
snd_init(DISABLE);
led_alert("green", DISABLE);
break;
case MODE_2NDBOOT:
led_alert("blue", DISABLE);
led_alert("red", ENABLE);
snd_boot(DISABLE);
led_alert("red", DISABLE);
break;
case MODE_BOOTMENU:
status = INSTALL_ERROR;
break;
}
}
if (status != INSTALL_SUCCESS) {
ui_init();
ui_set_background(BACKGROUND_ICON_ERROR);
ui_show_text(ENABLE);
LOGI("Start Android BootMenu....\n");
prompt_and_wait();
ui_finish();
}
led_alert("blue", DISABLE);
return EXIT_SUCCESS;
}
return EXIT_SUCCESS;
}
static HRESULT Procedure_invoke(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
{
script_ctx_t *ctx = This->desc->ctx;
HRESULT hres;
TRACE("\n");
IActiveScriptSite_OnEnterScript(ctx->site);
hres = exec_script(ctx, This->desc->value_func, NULL, NULL, NULL);
IActiveScriptSite_OnLeaveScript(ctx->site);
return hres;
}
/*
* The command-line arguments to ucblinks are:
*
* -r specify a root relative to which ./devices and ./dev
* are used to create links.
*
* -e the awk-based ucblinks had a default rule-base and
* allowed alternate rule-bases with -e. If the user
* specifies a rule-base we run the awk-based ucblinks
* and pass all the args to it.
*
* -d undocumented debug option (like the awk-based version);
* print what would be created, fixed, or is already correct.
*/
int
main(int argc, char **argv)
{
int c;
int err = 0;
(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif
(void) textdomain(TEXT_DOMAIN);
progname = argv[0]; /* save program name for error messages */
while ((c = getopt(argc, argv, "r:e:d")) != EOF) {
switch (c) {
case 'r':
rootdir = optarg;
break;
case 'e':
exec_script(argv);
/* exec_script doesn't return */
break;
case 'd':
debug = 1;
break;
case '?':
default:
err = 1;
break;
}
}
if (err || (optind != argc)) {
(void) fprintf(stderr, gettext("usage: %s [ -r rootdir ] "
"[ -e rulebase ]\n"), progname);
exit(1);
}
get_major_nums();
set_depth();
get_devices();
get_dev_links();
call_device_rules();
return (0);
}
/**
* main()
*
* Here is the hijack part, logwrapper is linked to bootmenu
* we trap some of logged commands from init.rc
*
*/
int main(int argc, char **argv) {
char* executable = argv[0];
int result;
if (argc == 2 && 0 == strcmp(argv[1], "postbootmenu")) {
exec_script(FILE_OVERCLOCK, DISABLE);
result = exec_script(FILE_POST_MENU, DISABLE);
bypass_sign("no");
sync();
return result;
}
else if (NULL != strstr(executable, "bootmenu")) {
fprintf(stdout, "Run BootMenu..\n");
result = run_bootmenu();
sync();
return result;
}
else if (argc >= 3 && 0 == strcmp(argv[2], "userdata")) {
result = run_bootmenu();
real_execute(argc, argv);
bypass_sign("no");
sync();
return result;
}
else if (argc >= 3 && 0 == strcmp(argv[2], "pds")) {
//kept for stock rom compatibility, please use postbootmenu
real_execute(argc, argv);
exec_script(FILE_OVERCLOCK, DISABLE);
result = exec_script(FILE_POST_MENU, DISABLE);
bypass_sign("no");
sync();
return result;
}
else {
return real_execute(argc, argv);
}
}
static BOOL run_terminator(vbdisp_t *This)
{
DISPPARAMS dp = {0};
if(This->terminator_ran)
return TRUE;
This->terminator_ran = TRUE;
if(!This->desc->class_terminate_id)
return TRUE;
This->ref++;
exec_script(This->desc->ctx, This->desc->funcs[This->desc->class_terminate_id].entries[VBDISP_CALLGET],
This, &dp, NULL);
return !--This->ref;
}
/**
* Execute a series of script commands in the named file.
*/
void exec_script_file (const char *filename)
{
FILE *in;
char buf[256];
in = fopen (filename, "r");
if (!in)
return;
simlog (SLC_DEBUG, "Reading commands from '%s'", filename);
for (;;)
{
if (!fgets (buf, 255, in))
break;
if (feof (in))
break;
exec_script (buf);
}
simlog (SLC_DEBUG, "Closing '%s'", filename);
fclose (in);
}
int execvp(const char * name, char * const argv[])
{
char * pathstr;
char * cp;
char fname[NAME_MAX];
unsigned etxtbsy = 1;
int eacces = 0;
pathstr = getenv("PATH");
if (!pathstr)
pathstr = _PATH_STDPATH;
cp = strchr(name, '/') ? "" : pathstr;
do {
cp = execat(cp, name, fname);
retry:
execve(fname, argv, environ);
switch (errno) {
case ENOEXEC:
return exec_script(argv, fname);
case ETXTBSY:
if (++etxtbsy > 5)
return -1;
sleep(etxtbsy);
goto retry;
case EACCES:
eacces = 1;
break;
case E2BIG:
case EFAULT:
case ENOMEM:
return -1;
}
} while (cp);
if (eacces)
errno = EACCES;
return -1;
}
static HRESULT WINAPI ScriptDisp_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
{
ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
ident_map_t *ident;
HRESULT hres;
TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
ident = id_to_ident(This, id);
if(!ident)
return DISP_E_MEMBERNOTFOUND;
if(ident->is_var) {
if(ident->u.var->is_const) {
FIXME("const not supported\n");
return E_NOTIMPL;
}
return invoke_variant_prop(This->ctx, &ident->u.var->v, wFlags, pdp, pvarRes);
}
switch(wFlags) {
case DISPATCH_METHOD:
case DISPATCH_METHOD|DISPATCH_PROPERTYGET:
IActiveScriptSite_OnEnterScript(This->ctx->site);
hres = exec_script(This->ctx, ident->u.func, NULL, pdp, pvarRes);
IActiveScriptSite_OnLeaveScript(This->ctx->site);
break;
default:
FIXME("Unsupported flags %x\n", wFlags);
hres = E_NOTIMPL;
}
return hres;
}
/**
* run_bootmenu()
*
*/
static int run_bootmenu(void) {
int defmode, mode, status = BUTTON_ERROR;
int adb_started = 0;
time_t start = time(NULL);
LOGI("Starting bootmenu on %s", ctime(&start));
if (bypass_check()) {
// init rootfs and mount cache
exec_script(FILE_PRE_MENU, DISABLE);
led_alert("blue", ENABLE);
defmode = get_default_bootmode();
// get and clean one shot bootmode (or default)
mode = get_bootmode(1,1);
if (mode == int_mode("bootmenu")
|| mode == int_mode("recovery")
|| mode == int_mode("shell")) {
// dont wait if these modes are asked
} else {
status = (wait_key(KEY_VOLUMEDOWN) ? BUTTON_PRESSED : BUTTON_TIMEOUT);
}
// only start adb if usb is connected
if (usb_connected()) {
if (mode == int_mode("2nd-init-adb")
|| mode == int_mode("2nd-boot-adb")
|| mode == int_mode("2nd-system-adb")) {
exec_script(FILE_ADBD, DISABLE);
adb_started = 1;
}
}
// on timeout
if (status != BUTTON_PRESSED) {
if (mode == int_mode("bootmenu")) {
led_alert("blue", DISABLE);
status = BUTTON_PRESSED;
}
else if (mode == int_mode("2nd-init") || mode == int_mode("2nd-init-adb")) {
led_alert("blue", DISABLE);
led_alert("green", ENABLE);
snd_init(DISABLE);
led_alert("green", DISABLE);
status = BUTTON_TIMEOUT;
}
else if (mode == int_mode("2nd-boot") || mode == int_mode("2nd-boot-adb")) {
led_alert("blue", DISABLE);
led_alert("red", ENABLE);
snd_boot(DISABLE);
led_alert("red", DISABLE);
status = BUTTON_TIMEOUT;
}
else if (mode == int_mode("2nd-system") || mode == int_mode("2nd-system-adb")) {
led_alert("blue", DISABLE);
led_alert("red", ENABLE);
led_alert("green", ENABLE);
snd_system(DISABLE);
led_alert("red", DISABLE);
led_alert("green", DISABLE);
status = BUTTON_TIMEOUT;
}
else if (mode == int_mode("recovery-dev")) {
led_alert("blue", DISABLE);
exec_script(FILE_CUSTOMRECOVERY, DISABLE);
status = BUTTON_TIMEOUT;
}
else if (mode == int_mode("recovery")) {
led_alert("blue", DISABLE);
exec_script(FILE_STABLERECOVERY, DISABLE);
status = BUTTON_TIMEOUT;
}
else if (mode == int_mode("shell")) {
led_alert("blue", DISABLE);
exec_script(FILE_ADBD, DISABLE);
status = BUTTON_PRESSED;
}
else if (mode == int_mode("normal") || mode == int_mode("normal-adb")) {
led_alert("blue", DISABLE);
stk_boot(DISABLE);
status = BUTTON_TIMEOUT;
}
}
if (status == BUTTON_PRESSED ) {
ui_init();
ui_set_background(BACKGROUND_DEFAULT);
ui_show_text(ENABLE);
led_alert("button-backlight", ENABLE);
LOGI("Start Android BootMenu....\n");
main_headers = prepend_title((const char**)MENU_HEADERS);
/* can be buggy, adb could lock filesystem
if (!adb_started && usb_connected()) {
ui_print("Usb connected, starting adb...\n\n");
exec_script(FILE_ADBD, DISABLE);
}
*/
ui_print("Default mode: %s\n", str_mode(defmode));
if (mode == int_mode("shell")) {
ui_print("\n");
ui_print("Current mode: %s\n", str_mode(mode));
if (!usb_connected()) {
ui_print(" But USB is not connected !\n");
}
}
checkup_report();
ui_reset_progress();
prompt_and_wait();
free_menu_headers(main_headers);
ui_finish();
}
}
return EXIT_SUCCESS;
}
int main(int c, char **v)
{
struct sockaddr_in server_addr, from;
socklen_t fromlen;
fd_set rfds;
struct tunnel_packet *tp;
char buf[MTU];
unsigned int buflen;
int ret;
int tun_fd;
int server_fd;
tp = (struct tunnel_packet *)buf;
if(c < 4) {
fprintf(stderr, "TCP/UDP/ICMP Tunnel over UDP\n"
"%s <hostname> <port> <passphrase>\n", v[0]);
return 0;
}
struct hostent* host_info = gethostbyname(v[1]);
if (host_info == NULL) {
fprintf(stderr, "%s: Invalid hostname or IPv4 address\n", v[1]);
return 1;
}
memset(&server_addr, 0, sizeof(server_addr));
memset(&from, 0, sizeof(from));
memcpy(&server_addr.sin_addr, host_info->h_addr, host_info->h_length);
if(strtoport(v[2], &server_addr.sin_port) == 0) {
fprintf(stderr, "%s: Invalid port\n", v[0]);
return 1;
}
server_addr.sin_family = AF_INET;
tun_fd = tun_create();
server_fd = socket_create(0);
/* Sending authentication */
tp->type = CONTROL_PACKET;
tp->cmd = AUTH_CMD;
strcpy(tp->data, PASSPHRASE);
socket_put_packet(server_fd, &server_addr, sizeof(server_addr), buf, sizeof(struct tunnel_packet) + strlen(PASSPHRASE));
/* Waiting acknowledge */
fromlen = sizeof(struct sockaddr_in);
buflen = socket_get_packet(server_fd, &from, &fromlen, buf, sizeof(buf));
if(tp->type == CONTROL_PACKET) {
if(tp->cmd != OK_CMD) {
puts("Password is incorret");
return 1;
}
} else {
puts("Unexpected packet was received.");
return 1;
}
#ifdef __linux__
exec_script("linux_client.sh", v[1]);
#else
exec_script("osx_client.sh", v[1]);
#endif
puts("+ Auth is OK.\n+ UDP Tunnel is running.");
FD_ZERO(&rfds);
while(1) {
FD_SET(server_fd, &rfds);
FD_SET(tun_fd, &rfds);
ret = select(server_fd+1, &rfds, NULL, NULL, NULL);
if(ret == -1)
break;
if(FD_ISSET(tun_fd, &rfds)) {
buflen = tun_get_packet(tun_fd, tp->data, sizeof(buf)-sizeof(struct tunnel_packet));
tp->type = TRAFFIC_PACKET;
tp->cmd = 0;
socket_put_packet(server_fd, &server_addr, sizeof(server_addr), buf, buflen + sizeof(struct tunnel_packet));
}
if(FD_ISSET(server_fd, &rfds)) {
buflen = socket_get_packet(server_fd, &from, &fromlen, buf, sizeof(buf));
if(server_addr.sin_addr.s_addr == from.sin_addr.s_addr && server_addr.sin_port == from.sin_port)
tun_put_packet(tun_fd, tp->data, buflen-sizeof(struct tunnel_packet));
}
}
return 1;
}
static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
{
vbdisp_t *This = impl_from_IDispatchEx(iface);
TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
if(!This->desc)
return E_UNEXPECTED;
if(pvarRes)
V_VT(pvarRes) = VT_EMPTY;
if(id < 0)
return DISP_E_MEMBERNOTFOUND;
if(is_func_id(This, id)) {
function_t *func;
switch(wFlags) {
case DISPATCH_PROPERTYGET:
func = This->desc->funcs[id].entries[VBDISP_CALLGET];
if(!func || (func->type != FUNC_PROPGET && func->type != FUNC_DEFGET)) {
WARN("no getter\n");
return DISP_E_MEMBERNOTFOUND;
}
return exec_script(This->desc->ctx, func, This, pdp, pvarRes);
case DISPATCH_METHOD:
case DISPATCH_METHOD|DISPATCH_PROPERTYGET:
func = This->desc->funcs[id].entries[VBDISP_CALLGET];
if(!func) {
FIXME("no invoke/getter\n");
return DISP_E_MEMBERNOTFOUND;
}
return exec_script(This->desc->ctx, func, This, pdp, pvarRes);
case DISPATCH_PROPERTYPUT:
case DISPATCH_PROPERTYPUTREF:
case DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF: {
DISPPARAMS dp = {NULL, NULL, 1, 0};
BOOL needs_release;
VARIANT put_val;
HRESULT hres;
if(arg_cnt(pdp)) {
FIXME("arguments not implemented\n");
return E_NOTIMPL;
}
hres = get_propput_arg(This->desc->ctx, pdp, wFlags, &put_val, &needs_release);
if(FAILED(hres))
return hres;
dp.rgvarg = &put_val;
func = This->desc->funcs[id].entries[V_VT(&put_val) == VT_DISPATCH ? VBDISP_SET : VBDISP_LET];
if(!func) {
FIXME("no letter/setter\n");
return DISP_E_MEMBERNOTFOUND;
}
hres = exec_script(This->desc->ctx, func, This, &dp, NULL);
if(needs_release)
VariantClear(&put_val);
return hres;
}
default:
FIXME("flags %x\n", wFlags);
return DISP_E_MEMBERNOTFOUND;
}
}
if(id < This->desc->prop_cnt + This->desc->func_cnt)
return invoke_variant_prop(This->desc->ctx, This->props+(id-This->desc->func_cnt), wFlags, pdp, pvarRes);
if(This->desc->builtin_prop_cnt) {
unsigned min = 0, max = This->desc->builtin_prop_cnt-1, i;
while(min <= max) {
i = (min+max)/2;
if(This->desc->builtin_props[i].id == id)
return invoke_builtin(This, This->desc->builtin_props+i, wFlags, pdp, pvarRes);
if(This->desc->builtin_props[i].id < id)
min = i+1;
else
max = i-1;
}
}
return DISP_E_MEMBERNOTFOUND;
}
/**
* pscc_runscript_call()
**/
int pscc_runscript_call(pscc_object_t*obj)
{
char *const argv[2] = {pscc_runscript_path,
NULL };
char **env = NULL;
int elem_size;
int env_idx = 0;
pscc_paramid_t id;
mpl_param_element_t* param_elem_p;
pid_t pid;
int status = 0;
int i,number_of_params;
int number_of_envs;
if (NULL == pscc_runscript_path)
return 0;
number_of_params = (sizeof(pscc_runscript_parameters)/sizeof(int));
number_of_envs = (number_of_params + 2);//2 here means the first element is for connection status
// and the last one is for "/0"
env = malloc(sizeof(char *) * number_of_envs);
if(NULL == env)
{
PSCC_DBG_TRACE(LOG_ERR, "malloc failed\n");
return(-1);
}
elem_size = strlen("connection_status") + strlen(pscc_names_connection_status[pscc_obj_get_state(obj)]) + 2;
env[env_idx] = malloc(elem_size);
if(NULL == env[env_idx])
{
PSCC_DBG_TRACE(LOG_ERR, "malloc failed\n");
free(env);
return(-1);
}
snprintf(env[env_idx], elem_size, "connection_status=%s", pscc_names_connection_status[pscc_obj_get_state(obj)]);
env_idx++;
for(i=0;i<number_of_params;i++)
{
id=pscc_runscript_parameters[i];
param_elem_p = pscc_get_param(obj->connid, id);
if (NULL == param_elem_p)
{
continue;
}
switch (id)
{
case pscc_paramid_dns_address:
{
mpl_param_element_t* tmp_elem_p = param_elem_p;
int my_idx = 0;
elem_size = strlen("dns_addresses=");
do
{
elem_size += snprintf(NULL, 0, "%s ",
mpl_param_value_get_string(id, tmp_elem_p->value_p));
} while (NULL != (tmp_elem_p = mpl_param_list_find_next(id, tmp_elem_p)));
elem_size++;
env[env_idx] = malloc(elem_size);
if(NULL == env[env_idx])
{
PSCC_DBG_TRACE(LOG_ERR, "malloc failed\n");
continue;
}
tmp_elem_p = param_elem_p;
strcpy(&env[env_idx][my_idx], "dns_addresses=");
my_idx += strlen("dns_addresses=");
do
{
my_idx += snprintf(&env[env_idx][my_idx], elem_size-my_idx, "%s ",
mpl_param_value_get_string(pscc_paramid_dns_address,
tmp_elem_p->value_p));
} while (NULL != (tmp_elem_p = mpl_param_list_find_next(pscc_paramid_dns_address, tmp_elem_p)));
env[env_idx][my_idx++]='\0';
break;
}
default:
elem_size = mpl_param_pack(param_elem_p, NULL, 0);
if (elem_size < 0)
{
PSCC_DBG_TRACE(LOG_ERR, "param_pack failed\n");
continue;
}
elem_size++;
env[env_idx] = malloc(elem_size);
if(NULL == env[env_idx])
{
PSCC_DBG_TRACE(LOG_ERR, "malloc failed\n");
continue;
}
elem_size = mpl_param_pack_no_prefix(param_elem_p, env[env_idx], elem_size);
if (elem_size < 0)
{
PSCC_DBG_TRACE(LOG_ERR, "param_pack failed\n");
free(env[env_idx]);
env[env_idx] = NULL;
continue;
}
break;
}
env_idx++;
}
env[env_idx] = NULL;
pid = exec_script(argv, env);
if (pid == -1)
status = -1;
else if (pid != 0) {
/* Wait for the script to finish */
while (waitpid(pid, &status, 0) == -1) {
if (errno != EINTR) {
PSCC_DBG_TRACE(LOG_ERR, "waitpid: %s", strerror(errno));
status = -1;
break;
}
}
}
/* Cleanup */
env_idx = 0;
while (env[env_idx] != NULL)
free(env[env_idx++]);
free(env);
return status;
}
static bool
exec_script(struct nv50_disp_priv *priv, int head, int id)
{
struct nouveau_bios *bios = nouveau_bios(priv);
struct nvbios_outp info;
struct dcb_output dcb;
u8 ver, hdr, cnt, len;
u32 ctrl = 0x00000000;
u16 data;
int outp;
for (outp = 0; !(ctrl & (1 << head)) && outp < 8; outp++) {
ctrl = nv_rd32(priv, 0x640180 + (outp * 0x20));
if (ctrl & (1 << head))
break;
}
if (outp == 8)
return false;
data = exec_lookup(priv, head, outp, ctrl, &dcb, &ver, &hdr, &cnt, &len, &info);
if (data) {
struct nvbios_init init = {
.subdev = nv_subdev(priv),
.bios = bios,
.offset = info.script[id],
.outp = &dcb,
.crtc = head,
.execute = 1,
};
return nvbios_exec(&init) == 0;
}
return false;
}
static u32
exec_clkcmp(struct nv50_disp_priv *priv, int head, int id,
u32 pclk, struct dcb_output *dcb)
{
struct nouveau_bios *bios = nouveau_bios(priv);
struct nvbios_outp info1;
struct nvbios_ocfg info2;
u8 ver, hdr, cnt, len;
u32 ctrl = 0x00000000;
u32 data, conf = ~0;
int outp;
for (outp = 0; !(ctrl & (1 << head)) && outp < 8; outp++) {
ctrl = nv_rd32(priv, 0x660180 + (outp * 0x20));
if (ctrl & (1 << head))
break;
}
if (outp == 8)
return false;
data = exec_lookup(priv, head, outp, ctrl, dcb, &ver, &hdr, &cnt, &len, &info1);
if (data == 0x0000)
return conf;
switch (dcb->type) {
case DCB_OUTPUT_TMDS:
conf = (ctrl & 0x00000f00) >> 8;
if (pclk >= 165000)
conf |= 0x0100;
break;
case DCB_OUTPUT_LVDS:
conf = priv->sor.lvdsconf;
break;
case DCB_OUTPUT_DP:
conf = (ctrl & 0x00000f00) >> 8;
break;
case DCB_OUTPUT_ANALOG:
default:
conf = 0x00ff;
break;
}
data = nvbios_ocfg_match(bios, data, conf, &ver, &hdr, &cnt, &len, &info2);
if (data && id < 0xff) {
data = nvbios_oclk_match(bios, info2.clkcmp[id], pclk);
if (data) {
struct nvbios_init init = {
.subdev = nv_subdev(priv),
.bios = bios,
.offset = data,
.outp = dcb,
.crtc = head,
.execute = 1,
};
nvbios_exec(&init);
}
}
return conf;
}
static void
nvd0_disp_intr_unk1_0(struct nv50_disp_priv *priv, int head)
{
exec_script(priv, head, 1);
}
int
main(int argc, char *argv[])
{
int ch;
struct sigaction sact;
struct hotplug_event he;
while ((ch = getopt(argc, argv, "d:")) != -1)
switch (ch) {
case 'd':
device = optarg;
break;
case '?':
default:
usage();
/* NOTREACHED */
}
argc -= optind;
argv += optind;
if (argc > 0)
usage();
if ((devfd = open(device, O_RDONLY)) == -1)
err(1, "%s", device);
bzero(&sact, sizeof(sact));
sigemptyset(&sact.sa_mask);
sact.sa_flags = 0;
sact.sa_handler = sigquit;
sigaction(SIGINT, &sact, NULL);
sigaction(SIGQUIT, &sact, NULL);
sigaction(SIGTERM, &sact, NULL);
sact.sa_handler = SIG_IGN;
sigaction(SIGHUP, &sact, NULL);
sact.sa_handler = sigchild;
sact.sa_flags = SA_NOCLDSTOP;
sigaction(SIGCHLD, &sact, NULL);
openlog(_LOG_TAG, _LOG_OPT, _LOG_FACILITY);
if (daemon(0, 0) == -1)
err(1, "daemon");
syslog(LOG_INFO, "started");
while (!quit) {
if (read(devfd, &he, sizeof(he)) == -1) {
if (errno == EINTR)
/* ignore */
continue;
syslog(LOG_ERR, "read: %m");
exit(1);
}
switch (he.he_type) {
case HOTPLUG_DEVAT:
syslog(LOG_INFO, "%s attached, class %d",
he.he_devname, he.he_devclass);
exec_script(_PATH_ETC_HOTPLUG_ATTACH, he.he_devclass,
he.he_devname);
break;
case HOTPLUG_DEVDT:
syslog(LOG_INFO, "%s detached, class %d",
he.he_devname, he.he_devclass);
exec_script(_PATH_ETC_HOTPLUG_DETACH, he.he_devclass,
he.he_devname);
break;
default:
syslog(LOG_NOTICE, "unknown event (0x%x)", he.he_type);
}
}
syslog(LOG_INFO, "terminated");
closelog();
close(devfd);
return (0);
}
int configure (const options_t *options, interface_t *iface,
const dhcp_t *dhcp)
{
route_t *route = NULL;
route_t *new_route = NULL;
route_t *old_route = NULL;
struct hostent *he = NULL;
char newhostname[HOSTNAME_MAX_LEN] = {0};
char curhostname[HOSTNAME_MAX_LEN] = {0};
char *dname = NULL;
int dnamel = 0;
if (! options || ! iface || ! dhcp)
return -1;
/* Remove old routes
Always do this as the interface may have >1 address not added by us
so the routes we added may still exist */
if (iface->previous_routes)
{
for (route = iface->previous_routes; route; route = route->next)
if (route->destination.s_addr || options->dogateway)
{
int have = 0;
if (dhcp->address.s_addr != 0)
for (new_route = dhcp->routes; new_route; new_route = new_route->next)
if (new_route->destination.s_addr == route->destination.s_addr
&& new_route->netmask.s_addr == route->netmask.s_addr
&& new_route->gateway.s_addr == route->gateway.s_addr)
{
have = 1;
break;
}
if (! have)
del_route (iface->name, route->destination, route->netmask,
route->gateway, options->metric);
}
}
/* If we don't have an address, then return */
if (dhcp->address.s_addr == 0)
{
if (iface->previous_routes)
{
free_route (iface->previous_routes);
iface->previous_routes = NULL;
}
/* Only reset things if we had set them before */
if (iface->previous_address.s_addr != 0)
{
del_address (iface->name, iface->previous_address,
iface->previous_netmask);
memset (&iface->previous_address, 0, sizeof (struct in_addr));
memset (&iface->previous_netmask, 0, sizeof (struct in_addr));
restore_resolv (iface->name);
/* we currently don't have a resolvconf style programs for ntp/nis */
exec_script (options->script, iface->infofile, "down");
}
return 0;
}
if (add_address (iface->name, dhcp->address, dhcp->netmask,
dhcp->broadcast) < 0 && errno != EEXIST)
return -1;
/* Now delete the old address if different */
if (iface->previous_address.s_addr != dhcp->address.s_addr
&& iface->previous_address.s_addr != 0)
del_address (iface->name, iface->previous_address, iface->previous_netmask);
#ifdef __linux__
/* On linux, we need to change the subnet route to have our metric. */
if (iface->previous_address.s_addr != dhcp->address.s_addr
&& options->metric > 0 && dhcp->netmask.s_addr != INADDR_BROADCAST)
{
struct in_addr td;
struct in_addr tg;
memset (&td, 0, sizeof (td));
memset (&tg, 0, sizeof (tg));
td.s_addr = dhcp->address.s_addr & dhcp->netmask.s_addr;
add_route (iface->name, td, dhcp->netmask, tg, options->metric);
del_route (iface->name, td, dhcp->netmask, tg, 0);
}
#endif
/* Remember added routes */
if (dhcp->routes)
{
route_t *new_routes = NULL;
int remember;
for (route = dhcp->routes; route; route = route->next)
{
/* Don't set default routes if not asked to */
if (route->destination.s_addr == 0 && route->netmask.s_addr == 0
&& ! options->dogateway)
continue;
remember = add_route (iface->name, route->destination,
route->netmask, route->gateway,
options->metric);
/* If we failed to add the route, we may have already added it
ourselves. If so, remember it again. */
if (remember < 0)
for (old_route = iface->previous_routes; old_route;
old_route = old_route->next)
if (old_route->destination.s_addr == route->destination.s_addr
&& old_route->netmask.s_addr == route->netmask.s_addr
&& old_route->gateway.s_addr == route->gateway.s_addr)
{
remember = 1;
break;
}
if (remember >= 0)
{
if (! new_routes)
{
new_routes = xmalloc (sizeof (route_t));
memset (new_routes, 0, sizeof (route_t));
new_route = new_routes;
}
else
{
new_route->next = xmalloc (sizeof (route_t));
new_route = new_route->next;
}
memcpy (new_route, route, sizeof (route_t));
new_route -> next = NULL;
}
}
if (iface->previous_routes)
free_route (iface->previous_routes);
iface->previous_routes = new_routes;
}
if (options->dodns && dhcp->dnsservers)
make_resolv(iface->name, dhcp);
else
logger (LOG_DEBUG, "no dns information to write");
if (options->dontp && dhcp->ntpservers)
make_ntp(iface->name, dhcp);
if (options->donis && (dhcp->nisservers || dhcp->nisdomain))
make_nis(iface->name, dhcp);
/* Now we have made a resolv.conf we can obtain a hostname if we need one */
if (options->dohostname && ! dhcp->hostname)
{
he = gethostbyaddr (inet_ntoa (dhcp->address),
sizeof (struct in_addr), AF_INET);
if (he)
{
dname = he->h_name;
while (*dname > 32)
dname++;
dnamel = dname - he->h_name;
memcpy (newhostname, he->h_name, dnamel);
newhostname[dnamel] = 0;
}
}
gethostname (curhostname, sizeof (curhostname));
if (options->dohostname
|| strlen (curhostname) == 0
|| strcmp (curhostname, "(none)") == 0
|| strcmp (curhostname, "localhost") == 0)
{
if (dhcp->hostname)
strcpy (newhostname, dhcp->hostname);
if (*newhostname)
{
logger (LOG_INFO, "setting hostname to `%s'", newhostname);
sethostname (newhostname, strlen (newhostname));
}
}
write_info (iface, dhcp, options);
if (iface->previous_address.s_addr != dhcp->address.s_addr ||
iface->previous_netmask.s_addr != dhcp->netmask.s_addr)
{
memcpy (&iface->previous_address,
&dhcp->address, sizeof (struct in_addr));
memcpy (&iface->previous_netmask,
&dhcp->netmask, sizeof (struct in_addr));
exec_script (options->script, iface->infofile, "new");
}
else
exec_script (options->script, iface->infofile, "up");
return 0;
}
/** Main loop for handling the user interface. */
static void sim_interface_thread (void)
{
char inbuf[2];
struct key_binding *kb;
int simulator_keys = 1;
int toggle_mode = 1;
#ifndef CONFIG_UI_SDL
/* Put stdin in raw mode so that 'enter' doesn't have to
be pressed after each keystroke. */
keybuffering (0);
/* Let the system initialize before accepting keystrokes */
task_sleep_sec (3);
#endif
if (exec_file && exec_late_flag)
exec_script_file (exec_file);
for (;;)
{
task_yield ();
#ifdef CONFIG_GTK
gtk_poll ();
#endif
#ifdef CONFIG_UI_SDL
ui_refresh_all ();
*inbuf = ui_poll_events ();
#else
*inbuf = sim_getchar ();
#endif
/* Try again if no character was read */
if (*inbuf == '\0')
continue;
/* If switch simulation is turned off, then keystrokes
are fed into the simulated serial port... meaning it is interpreted
by the game program itself, and not the simulator. Use the
tilde to toggle between the two modes. */
if (simulator_keys == 0)
{
/* Except tilde turns it off as usual. */
if (*inbuf == '`')
{
simlog (SLC_DEBUG, "Input directed to switch matrix.");
simulator_keys ^= 1;
}
else
{
wpc_key_press (*inbuf);
}
continue;
}
switch (*inbuf)
{
/* Carriage returns and line feeds are ignored so that you can
put these commands into a script file. */
case '\r':
case '\n':
break;
case ':':
{
/* Read and execute a script command */
char cmd[128];
char *p = cmd;
memset (p, 0, 128);
ui_print_command (" ");
for (;;)
{
*p = sim_getchar ();
if (*p == '\x1B')
{
break;
}
else if (*p == '\010')
{
*p = '\0';
p--;
}
else if ((*p == '\r') || (*p == '\n'))
{
*p = '\0';
exec_script (cmd);
break;
}
ui_print_command (cmd);
p++;
}
ui_print_command ("");
break;
}
case 'C':
gdb_break ();
break;
case '{':
signal_trace_start (signo_under_trace);
break;
case '}':
signal_trace_stop (signo_under_trace);
break;
case 'q':
node_kick (&open_node);
break;
case '`':
/* The tilde toggles between keystrokes being treated as switches,
and as input into the runtime debugger. */
simulator_keys ^= 1;
simlog (SLC_DEBUG, "Input directed to built-in debugger.");
break;
case '\x1b':
sim_exit (0);
break;
case 'T':
task_dump ();
break;
case '#':
/* Treat '#' as a comment until end of line.
This is useful for creating scripts. */
do {
*inbuf = sim_getchar ();
} while (*inbuf != '\n');
break;
case '"':
simlog (SLC_DEBUG, "next key will toggle, not press");
toggle_mode = 0;
break;
default:
/* For all other keystrokes, use the keymap table
to turn the keystroke into a switch trigger. */
kb = &keymaps[(int)*inbuf];
#ifdef MACHINE_SHOOTER_SWITCH
if (kb->flags & KEY_SHOOTER)
{
node_kick (&shooter_node);
}
else
#endif
if (kb->flags & KEY_NODE)
{
node_move (kb->node, &open_node);
}
else if (kb->flags & KEY_SW)
{
if ((switch_table[kb->sw].flags & SW_EDGE) || !toggle_mode)
{
simlog (SLC_DEBUG, "switch %d toggled", kb->sw);
sim_switch_toggle (kb->sw);
toggle_mode = 1;
}
#if (MACHINE_FLIPTRONIC == 1)
else if (kb->sw >= 72)
{
flipper_button_depress (kb->sw);
}
#endif
else
{
sim_switch_depress (kb->sw);
}
}
else
simlog (SLC_DEBUG, "invalid key '%c' pressed (0x%02X)",
*inbuf, *inbuf);
}
}
}
static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
{
vbdisp_t *This = impl_from_IDispatchEx(iface);
TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
if(!This->desc)
return E_UNEXPECTED;
if(pvarRes)
V_VT(pvarRes) = VT_EMPTY;
if(id < 0)
return DISP_E_MEMBERNOTFOUND;
if(is_func_id(This, id)) {
function_t *func;
switch(wFlags) {
case DISPATCH_METHOD:
case DISPATCH_METHOD|DISPATCH_PROPERTYGET:
func = This->desc->funcs[id].entries[VBDISP_CALLGET];
if(!func) {
FIXME("no invoke/getter\n");
return DISP_E_MEMBERNOTFOUND;
}
return exec_script(This->desc->ctx, func, (IDispatch*)&This->IDispatchEx_iface, pdp, pvarRes);
case DISPATCH_PROPERTYPUT: {
VARIANT *put_val;
DISPPARAMS dp = {NULL, NULL, 1, 0};
if(arg_cnt(pdp)) {
FIXME("arguments not implemented\n");
return E_NOTIMPL;
}
put_val = get_propput_arg(pdp);
if(!put_val) {
WARN("no value to set\n");
return DISP_E_PARAMNOTOPTIONAL;
}
dp.rgvarg = put_val;
func = This->desc->funcs[id].entries[V_VT(put_val) == VT_DISPATCH ? VBDISP_SET : VBDISP_LET];
if(!func) {
FIXME("no letter/setter\n");
return DISP_E_MEMBERNOTFOUND;
}
return exec_script(This->desc->ctx, func, (IDispatch*)&This->IDispatchEx_iface, &dp, NULL);
}
default:
FIXME("flags %x\n", wFlags);
return DISP_E_MEMBERNOTFOUND;
}
}
if(id < This->desc->prop_cnt + This->desc->func_cnt)
return invoke_variant_prop(This, This->props+(id-This->desc->func_cnt), wFlags, pdp, pvarRes);
if(This->desc->builtin_prop_cnt) {
unsigned min = 0, max = This->desc->builtin_prop_cnt-1, i;
while(min <= max) {
i = (min+max)/2;
if(This->desc->builtin_props[i].id == id)
return invoke_builtin(This, This->desc->builtin_props+i, wFlags, pdp, pvarRes);
if(This->desc->builtin_props[i].id < id)
min = i+1;
else
max = i-1;
}
}
return DISP_E_MEMBERNOTFOUND;
}
static void
nv50_disp_intr_unk20_0(struct nv50_disp_priv *priv, int head)
{
exec_script(priv, head, 2);
}
char *do_convert(char *what, int what_len, int type, script *pscript)
{
switch(type)
{
case CONVTYPE_SIGNRTOSTRING:
{
int signr = atoi(what);
if (signr > n_known_sigs || signr < 1)
return mystrdup("unknown signal");
return mystrdup(sigs[signr]);
}
case CONVTYPE_TAI64NTODATE:
{
long long int v2_62 = (long long int)1 << (long long int)62;
long long int val = 0;
int loop;
if (what[0] == '@')
what++;
/* http://cr.yp.to/libtai/tai64.html#tai64n */
/* convert to 64 bit integer */
for(loop=0; loop<(8 * 2); loop++)
{
int c = tolower(what[loop]);
val <<= (long long int)4;
if (c >= 'a')
val += 10 + c - 'a';
else
val += c - '0';
}
if (val >= v2_62) /* FIXME: 2^63 are reserved, not checking for that, sorry */
{
char *new_str = epoch_to_str((time_t)(val - v2_62));
if (new_str)
return new_str;
else
return mystrdup("cannot convert current 'TAI64N'-date to string");
}
else
{
/* before 1970/1/1 now what should I do with that? */
return mystrdup("cannot convert 'TAI64N'-dates before the epoch");
}
}
case CONVTYPE_IP4TOHOST:
{
if (resolv_ip_addresses)
{
struct hostent *ht;
in_addr_t addr = inet_addr(what);
if ((int)addr == -1)
return mystrdup(what);
if ((ht = gethostbyaddr((char *)&addr, sizeof(addr), AF_INET)) == NULL)
return mystrdup(what);
return mystrdup(ht -> h_name);
}
return mystrdup(what);
}
break;
case CONVTYPE_EPOCHTODATE:
{
char *new_str = epoch_to_str((time_t)atoll(what));
if (new_str)
return new_str;
else
return mystrdup("cannot convert current epoch value");
}
break;
case CONVTYPE_ERRNO:
{
return mystrdup(strerror(atoi(what)));
}
case CONVTYPE_HEXTODEC:
{
long long int result = strtoll(what, NULL, 16);
char result_str[128];
snprintf(result_str, sizeof(result_str), "%lld", result);
return mystrdup(result_str);
}
case CONVTYPE_DECTOHEX:
{
long long int result = atoll(what);
char result_str[128];
snprintf(result_str, sizeof(result_str), "%llx", result);
return mystrdup(result_str);
}
case CONVTYPE_SCRIPT:
{
int rc;
char *send_buffer = mymalloc(what_len + 1 + 1);
char *result_str = mymalloc(SCRIPT_IO_BUFFER_SIZE);
exec_script(pscript);
memcpy(send_buffer, what, what_len);
send_buffer[what_len] = '\n';
send_buffer[what_len + 1] = 0x00;
WRITE(pscript -> fd_w, send_buffer, what_len + 1, "conversion script (is it still running?)");
myfree(send_buffer);
rc = READ(pscript -> fd_r, result_str, SCRIPT_IO_BUFFER_SIZE - 1, pscript -> script);
result_str[rc > 0?rc - 1:rc] = 0x00;
return result_str;
}
case CONVTYPE_ABBRTOK:
return amount_to_str(atoll(what));
default:
error_exit(FALSE, FALSE, "Internal error: unknown conversion type %d.\n", type);
}
return "do_convert: INTERNAL ERROR";
}
