entry_t copy_entry(entry_t other){
entry_t r = NULL;
if(other == NULL){
return NULL;
}
switch(other->type_tag){
case ENTRY_INT:
r = new_entry_int(
other->e.scalar_int,
other->name);
break;
case ENTRY_STR:
r = new_entry_str(
other->e.scalar_str,
other->name);
break;
case ENTRY_MAP:
r = new_entry_map(copy_config(other->e.conf), other->name);
break;
case ENTRY_SEQ:
r = new_entry_seq(copy_sequence(other->e.seq), other->name);
break;
default: //NULL
r = new_entry_null();
}
return r;
}
/* reset configuration to saved and close dialog */
void
on_cancel_pref_button_clicked (GtkButton * button, gpointer user_data)
{
/* reset configuration to saved */
copy_config(&pref, tmp_pref);
ask_reposition(TRUE);
if (colors_changed)
{
protohash_read_prefvect(pref.colors);
delete_gui_protocols ();
}
hide_pref_dialog();
} /* on_cancel_pref_button_clicked */
/* duplicates a config */
struct pref_struct *
duplicate_config(const struct pref_struct *src)
{
struct pref_struct *t;
t = g_malloc(sizeof(struct pref_struct));
g_assert(t);
t->filter = NULL;
t->text_color = NULL;
t->fontname = NULL;
t->colors = NULL;
t->center_node = NULL;
copy_config(t, src);
return t;
}
static int
config_handler(TSCont cont, TSEvent event, void *edata)
{
plugin_state_t *pstate;
invalidate_t *i, *iptr;
TSCont free_cont;
bool updated;
TSMutex mutex;
mutex = TSContMutexGet(cont);
TSMutexLock(mutex);
TSDebug(LOG_PREFIX, "In config Handler");
pstate = (plugin_state_t *)TSContDataGet(cont);
i = copy_config(pstate->invalidate_list);
updated = prune_config(&i);
updated = load_config(pstate, &i) || updated;
if (updated) {
list_config(pstate, i);
iptr = __sync_val_compare_and_swap(&(pstate->invalidate_list), pstate->invalidate_list, i);
if (iptr) {
free_cont = TSContCreate(free_handler, TSMutexCreate());
TSContDataSet(free_cont, (void *)iptr);
TSContScheduleOnPool(free_cont, FREE_TMOUT, TS_THREAD_POOL_TASK);
}
} else {
TSDebug(LOG_PREFIX, "No Changes");
if (i) {
free_invalidate_t_list(i);
}
}
TSMutexUnlock(mutex);
// Don't reschedule for TS_EVENT_MGMT_UPDATE
if (event == TS_EVENT_TIMEOUT) {
TSContScheduleOnPool(cont, CONFIG_TMOUT, TS_THREAD_POOL_TASK);
}
return 0;
}
static int ep0_get_descriptor (struct usb_device_instance *device,
struct urb *urb,
int max,
int descriptor_type,
int index)
{
char *cp;
urb->actual_length = 0;
cp = (char*)urb->buffer;
switch (descriptor_type) {
case USB_DESCRIPTOR_TYPE_DEVICE:
{
struct usb_device_descriptor *device_descriptor;
if (!(device_descriptor = usbd_device_device_descriptor(device)))
return -1;
copy_config(urb, device_descriptor, sizeof(struct usb_device_descriptor), max);
}
break;
case USB_DESCRIPTOR_TYPE_CONFIGURATION:
{
struct usb_configuration_descriptor *configuration_descriptor;
struct usb_device_descriptor *device_descriptor;
usb_info("get configuration, index = %d\n", index);
if (!(device_descriptor = usbd_device_device_descriptor (device)))
return -1;
if (index >= device_descriptor->bNumConfigurations) {
return -1;
}
if (!(configuration_descriptor = usbd_device_configuration_descriptor (device, index)))
return -1;
copy_config (urb, configuration_descriptor,
cpu_to_le16(configuration_descriptor->wTotalLength), max);
}
break;
case USB_DESCRIPTOR_TYPE_STRING:
{
struct usb_string_descriptor *string_descriptor;
usb_info("get string, index = %d, max = %d\n", index, max);
string_descriptor = usbd_get_string (index);
// if (!(string_descriptor))
// return -1;
copy_config (urb, string_descriptor, string_descriptor->bLength, max);
}
break;
case USB_DESCRIPTOR_TYPE_DEVICE_QUALIFIER:
//TODO
case USB_DESCRIPTOR_TYPE_OTHER_SPEED_CONFIGURATION:
//TODO
case USB_DESCRIPTOR_TYPE_INTERFACE: //should not see this
case USB_DESCRIPTOR_TYPE_ENDPOINT: //should not see this
default:
return -1;
}
return 0;
}
long shim_do_sandbox_create (int flags, const char * fs_sb,
struct net_sb * net_sb)
{
unsigned int sbid;
char uri[24];
PAL_HANDLE handle = NULL;
int ret = create_handle("file:sandbox-", uri, 24, &handle, &sbid);
if (ret < 0)
return ret;
debug("create manifest: %s\n", uri);
struct config_store * newcfg = __alloca(sizeof(struct config_store));
memset(newcfg, 0, sizeof(struct config_store));
newcfg->malloc = __malloc;
newcfg->free = __free;
if ((ret = copy_config(root_config, newcfg)) < 0) {
newcfg = NULL;
goto err;
}
if (flags & SANDBOX_FS)
if ((ret = isolate_fs(newcfg, fs_sb)) < 0)
goto err;
if (flags & SANDBOX_NET)
if ((ret = isolate_net(newcfg, net_sb)) < 0)
goto err;
struct cfg_arg arg;
arg.handle = handle;
arg.offset = 0;
if ((ret = write_config(&arg, __write, newcfg)) < 0)
goto err;
DkObjectClose(handle);
PAL_BOL success = DkProcessSandboxCreate(uri, flags & SANDBOX_RPC ?
PAL_SANDBOX_PIPE : 0);
if (!success) {
ret = -PAL_ERRNO;
goto err;
}
if (sandbox_info.sbid) {
if (!sandbox_info.parent_sbid ||
sandbox_info.parent_vmid != cur_process.vmid) {
sandbox_info.parent_sbid = sandbox_info.sbid;
sandbox_info.parent_vmid = cur_process.vmid;
}
}
if (flags & SANDBOX_RPC)
del_all_ipc_ports(0);
if ((ret = free_config(root_config)) < 0)
goto err;
handle = DkStreamOpen(uri, PAL_ACCESS_RDONLY, 0, 0, 0);
if (!handle)
return -PAL_ERRNO;
root_config = newcfg;
sandbox_info.sbid = sbid;
return sbid;
err:
free_config(newcfg);
DkStreamDelete(handle, 0);
DkObjectClose(handle);
return ret;
}
/*
* This function is the configuration box.
* (Being a dialog procedure, in general it returns 0 if the default
* dialog processing should be performed, and 1 if it should not.)
*/
static INT_PTR CALLBACK
config_dialog_proc(HWND wnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg) {
when WM_INITDIALOG: {
ctrlbox = ctrl_new_box();
setup_config_box(ctrlbox);
windlg_init();
winctrl_init(&ctrls_base);
winctrl_init(&ctrls_panel);
windlg_add_tree(&ctrls_base);
windlg_add_tree(&ctrls_panel);
copy_config("dialog", &new_cfg, &file_cfg);
RECT r;
GetWindowRect(GetParent(wnd), &r);
dlg.wnd = wnd;
/*
* Create the actual GUI widgets.
*/
// here we need the correct DIALOG_HEIGHT already
create_controls(wnd, ""); /* Open and Cancel buttons etc */
SendMessage(wnd, WM_SETICON, (WPARAM) ICON_BIG,
(LPARAM) LoadIcon(inst, MAKEINTRESOURCE(IDI_MAINICON)));
/*
* Create the tree view.
*/
r.left = 3;
r.right = r.left + 64;
r.top = 3;
r.bottom = r.top + DIALOG_HEIGHT - 26;
MapDialogRect(wnd, &r);
HWND treeview =
CreateWindowEx(WS_EX_CLIENTEDGE, WC_TREEVIEW, "",
WS_CHILD | WS_VISIBLE | WS_TABSTOP | TVS_HASLINES |
TVS_DISABLEDRAGDROP | TVS_HASBUTTONS | TVS_LINESATROOT
| TVS_SHOWSELALWAYS, r.left, r.top, r.right - r.left,
r.bottom - r.top, wnd, (HMENU) IDCX_TREEVIEW, inst,
null);
WPARAM font = SendMessage(wnd, WM_GETFONT, 0, 0);
SendMessage(treeview, WM_SETFONT, font, MAKELPARAM(true, 0));
treeview_faff tvfaff;
tvfaff.treeview = treeview;
memset(tvfaff.lastat, 0, sizeof (tvfaff.lastat));
/*
* Set up the tree view contents.
*/
HTREEITEM hfirst = null;
char *path = null;
for (int i = 0; i < ctrlbox->nctrlsets; i++) {
controlset *s = ctrlbox->ctrlsets[i];
HTREEITEM item;
int j;
char *c;
if (!s->pathname[0])
continue;
j = path ? ctrl_path_compare(s->pathname, path) : 0;
if (j == INT_MAX)
continue; /* same path, nothing to add to tree */
/*
* We expect never to find an implicit path
* component. For example, we expect never to see
* A/B/C followed by A/D/E, because that would
* _implicitly_ create A/D. All our path prefixes
* are expected to contain actual controls and be
* selectable in the treeview; so we would expect
* to see A/D _explicitly_ before encountering
* A/D/E.
*/
c = strrchr(s->pathname, '/');
if (!c)
c = s->pathname;
else
c++;
item = treeview_insert(&tvfaff, j, c, s->pathname);
if (!hfirst)
hfirst = item;
path = s->pathname;
/*
* Put the treeview selection on to the Session panel.
* This should also cause creation of the relevant
* controls.
*/
TreeView_SelectItem(treeview, hfirst);
}
/*
* Set focus into the first available control.
*/
for (winctrl *c = ctrls_panel.first; c; c = c->next) {
if (c->ctrl) {
dlg_set_focus(c->ctrl);
break;
}
}
}
when WM_DESTROY:
winctrl_cleanup(&ctrls_base);
winctrl_cleanup(&ctrls_panel);
ctrl_free_box(ctrlbox);
config_wnd = 0;
when WM_NOTIFY: {
if (LOWORD(wParam) == IDCX_TREEVIEW &&
((LPNMHDR) lParam)->code == TVN_SELCHANGED) {
HTREEITEM i = TreeView_GetSelection(((LPNMHDR) lParam)->hwndFrom);
TVITEM item;
char buffer[64];
item.hItem = i;
item.pszText = buffer;
item.cchTextMax = sizeof (buffer);
item.mask = TVIF_TEXT | TVIF_PARAM;
TreeView_GetItem(((LPNMHDR) lParam)->hwndFrom, &item);
/* Destroy all controls in the currently visible panel. */
for (winctrl *c = ctrls_panel.first; c; c = c->next) {
for (int k = 0; k < c->num_ids; k++) {
HWND item = GetDlgItem(wnd, c->base_id + k);
if (item)
DestroyWindow(item);
}
}
winctrl_cleanup(&ctrls_panel);
// here we need the correct DIALOG_HEIGHT already
create_controls(wnd, (char *) item.lParam);
dlg_refresh(null); /* set up control values */
}
}
when WM_CLOSE:
DestroyWindow(wnd);
when WM_COMMAND or WM_DRAWITEM: {
int ret = winctrl_handle_command(msg, wParam, lParam);
if (dlg.ended)
DestroyWindow(wnd);
return ret;
}
when WM_USER: {
HWND target = (HWND)wParam;
// could delegate this to winctrls.c, like winctrl_handle_command;
// but then we'd have to fiddle with the location of dragndrop
/*
* Look up the window handle in our data; find the control.
(Hmm, apparently it works without looking for the widget entry
that was particularly introduced for this purpose...)
*/
control * ctrl = null;
for (winctrl *c = ctrls_panel.first; c && !ctrl; c = c->next) {
if (c->ctrl)
for (int k = 0; k < c->num_ids; k++) {
#ifdef debug_dragndrop
printf(" [->%8p] %8p\n", target, GetDlgItem(wnd, c->base_id + k));
#endif
if (target == GetDlgItem(wnd, c->base_id + k)) {
ctrl = c->ctrl;
break;
}
}
}
if (ctrl) {
//dlg_editbox_set_w(ctrl, L"Test"); // may hit unrelated items...
// drop the drag-and-drop contents here
dragndrop = (wstring)lParam;
ctrl->handler(ctrl, EVENT_DROP);
}
}
}
return 0;
}
