From 532d163727963f8ac3a860914bd0801240352cb6 Mon Sep 17 00:00:00 2001 From: Bryan Roe Date: Mon, 28 Feb 2022 12:31:00 -0800 Subject: [PATCH] 1. Removed debug line from user-sessions 2. Added XKB extension support 3. Added linux support for SCROLL/NUM/CAPS --- meshcore/KVM/Linux/linux_events.c | 33 +++++++ meshcore/KVM/Linux/linux_events.h | 37 +++++++ meshcore/KVM/Linux/linux_kvm.c | 120 +++++++++++++++++------ meshcore/KVM/Linux/linux_kvm.h | 2 +- meshcore/agentcore.c | 3 +- microscript/ILibDuktape_GenericMarshal.c | 1 - microscript/ILibDuktape_Polyfills.c | 4 +- modules/monitor-info.js | 26 ++++- modules/user-sessions.js | 3 +- 9 files changed, 191 insertions(+), 38 deletions(-) diff --git a/meshcore/KVM/Linux/linux_events.c b/meshcore/KVM/Linux/linux_events.c index 4cc2295..4e2f35c 100644 --- a/meshcore/KVM/Linux/linux_events.c +++ b/meshcore/KVM/Linux/linux_events.c @@ -16,6 +16,8 @@ limitations under the License. #include "linux_events.h" #include "microstack/ILibParsers.h" +#include "meshcore/meshdefines.h" + static const int g_keymapLen = 96; // Modify this when you change anything in g_keymap. @@ -25,6 +27,10 @@ extern void kvm_keyboard_unmap_unicode_key(Display *display, int keycode); extern int kvm_keyboard_map_unicode_key(Display *display, uint16_t unicode, int *alreadyExists); extern int kvm_keyboard_update_map_unicode_key(Display *display, uint16_t unicode, int keycode); extern int SHIFT_STATE; +extern xkb_struct *xkb_exports; +extern x11_struct *x11_exports; +extern FILE *logFile; +extern int slave2master[2]; #define g_keyboardMapCount 8 int g_keyboardMap[g_keyboardMapCount] = { 0 }; @@ -198,6 +204,33 @@ void KeyAction(unsigned char vk, int up, Display *display) unsigned int keycode = 0; if (up == 4) { up = 0; } + + if (up && (vk == 0x14 || vk == 0x90 || vk == 0x91)) + { + XkbStateRec ptr; + xkb_exports->XkbGetState(display, XkbUseCoreKbd, &ptr); + + switch (vk) + { + case 0x14: // CAPS LOCK + xkb_exports->XkbLockModifiers(display, XkbUseCoreKbd, LockMask, (ptr.mods & 2) == 2 ? 0 : 2); + break; + case 0x90: // NUM LOCK + xkb_exports->XkbLockModifiers(display, XkbUseCoreKbd, Mod2Mask, (ptr.mods & 16) == 16 ? 0 : 16); + break; + case 0x91: // SCROLL LOCK + xkb_exports->XkbLockModifiers(display, XkbUseCoreKbd, Mod3Mask, (ptr.mods & 32) == 32 ? 0 : 32); + break; + } + x11_exports->XSync(display, 0); // Sync with XServer + xkb_exports->XkbGetState(display, XkbUseCoreKbd, &ptr); + char buffer[5]; + ((unsigned short*)buffer)[0] = (unsigned short)htons((unsigned short)MNG_KVM_KEYSTATE); // Write the type + ((unsigned short*)buffer)[1] = (unsigned short)htons((unsigned short)5); // Write the size + buffer[4] = (((ptr.mods & 16) == 16) | (((ptr.mods & 32) == 32) << 1) | (((ptr.mods & 2) == 2) << 2)); + ignore_result(write(slave2master[1], buffer, sizeof(buffer))); + } + if (change_display) { return; diff --git a/meshcore/KVM/Linux/linux_events.h b/meshcore/KVM/Linux/linux_events.h index bc1aac3..bcb0c41 100644 --- a/meshcore/KVM/Linux/linux_events.h +++ b/meshcore/KVM/Linux/linux_events.h @@ -19,12 +19,39 @@ limitations under the License. #include #include +#include #include #include #include #include #include "microstack/ILibParsers.h" +typedef struct x11_struct +{ + void *x11_lib; + Display*(*XOpenDisplay)(char *display_name); + int(*XCloseDisplay)(Display *d); + int(*XFlush)(Display *d); + KeyCode(*XKeysymToKeycode)(Display *d, KeySym keysym); + Bool(*XQueryExtension)(Display *d, char *name, int* maj, int *firstev, int *firsterr); + + int(*XConnectionNumber)(Display *d); + char*(*XGetAtomName)(Display *d, Atom atom); + void(*XNextEvent)(Display *d, XEvent *event_return); + int(*XPending)(Display *d); + Window(*XRootWindow)(Display *d, int screen_number); + void(*XSync)(Display *d, Bool discard); + void(*XFree)(void *data); + void(*XSelectInput)(Display *d, Window w, long mask); + int(*XGetWindowAttributes)(Display *d, Window w, XWindowAttributes *a); + void(*XChangeWindowAttributes)(Display *d, Window w, unsigned long valuemask, XSetWindowAttributes *a); + int(*XQueryPointer)(Display *d, Window w, Window *rr, Window *cr, int *rx, int *ry, int *wx, int *wy, unsigned int *mr); + int(*XDisplayKeycodes)(Display *display, int *min_keycodes_return, int *max_keycodes_return); + KeySym*(*XGetKeyboardMapping)(Display *display, KeyCode first_keycode, int keycode_count, int *keysyms_per_keycode_return); + KeySym(*XStringToKeysym)(char *string); + int(*XChangeKeyboardMapping)(Display *display, int first_keycode, int keysyms_per_keycode, KeySym *keysyms, int num_codes); + int(*XScreenCount)(Display *display); +}x11_struct; typedef struct x11tst_struct { @@ -36,7 +63,17 @@ typedef struct x11tst_struct int(*XFlush)(Display *d); KeyCode(*XKeysymToKeycode)(Display *d, KeySym keysym); }x11tst_struct; +typedef struct xkb_struct +{ + void *xkb_lib; + Bool(*XkbGetState)(Display *display, uint32_t device_spec, XkbStatePtr state_return); + Bool(*XkbLockModifiers)(Display *display, uint32_t device_spec, uint32_t affect, uint32_t values); + Bool(*XkbQueryExtension)(Display *dpy, int *opcode_rtrn, int *event_rtrn, int *error_rtrn, int *major_in_out, int *minor_in_out); + Bool(*XkbSelectEvents)(Display *display, uint32_t device_spec, uint64_t bits_to_change, uint64_t values_for_bits); +}xkb_struct; + extern x11tst_struct *x11tst_exports; +extern xkb_struct* xkb_exports; enum MOUSE_EVENTS { MOUSEEVENTF_LEFTDOWN = 0x0002, diff --git a/meshcore/KVM/Linux/linux_kvm.c b/meshcore/KVM/Linux/linux_kvm.c index d172657..5628911 100644 --- a/meshcore/KVM/Linux/linux_kvm.c +++ b/meshcore/KVM/Linux/linux_kvm.c @@ -71,6 +71,36 @@ typedef enum KVM_MouseCursors KVM_MouseCursor_NOTALLOWED = 15 }KVM_MouseCursors; +typedef struct _XkbStateNotifyEvent +{ + int type; /* XkbAnyEvent */ + unsigned long serial; /* # of last req processed by server */ + int send_event; /* is this from a SendEvent request? */ + void *display; /* Display the event was read from */ + uint64_t time; /* milliseconds */ + int xkb_type; /* XkbStateNotify */ + int device; /* device ID */ + unsigned int changed; /* mask of changed state components */ + int group; /* keyboard group */ + int base_group; /* base keyboard group */ + int latched_group; /* latched keyboard group */ + int locked_group; /* locked keyboard group */ + unsigned int mods; /* modifier state */ + unsigned int base_mods; /* base modifier state */ + unsigned int latched_mods; /* latched modifiers */ + unsigned int locked_mods; /* locked modifiers */ + int compat_state; /* compatibility state */ + unsigned char grab_mods; /* mods used for grabs */ + unsigned char compat_grab_mods; /* grab mods for non-XKB clients */ + unsigned char lookup_mods; /* mods sent to clients */ + unsigned char compat_lookup_mods; /* mods sent to non-XKB clients */ + int ptr_buttons; /* pointer button state */ + char keycode; /* keycode that caused the change */ + char event_type; /* KeyPress or KeyRelease */ + char req_major; /* Major opcode of request */ + char req_minor; /* Minor opcode of request */ +} XkbStateNotifyEvent; + int curcursor = KVM_MouseCursor_HELP; int SLAVELOG = 0; @@ -123,33 +153,6 @@ typedef struct x11ext_struct }x11ext_struct; x11ext_struct *x11ext_exports = NULL; extern x11tst_struct *x11tst_exports; - -typedef struct x11_struct -{ - void *x11_lib; - Display*(*XOpenDisplay)(char *display_name); - int(*XCloseDisplay)(Display *d); - int(*XFlush)(Display *d); - KeyCode(*XKeysymToKeycode)(Display *d, KeySym keysym); - Bool(*XQueryExtension)(Display *d, char *name, int* maj, int *firstev, int *firsterr); - - int(*XConnectionNumber)(Display *d); - char*(*XGetAtomName)(Display *d, Atom atom); - void(*XNextEvent)(Display *d, XEvent *event_return); - int(*XPending)(Display *d); - Window(*XRootWindow)(Display *d, int screen_number); - void(*XSync)(Display *d, Bool discard); - void(*XFree)(void *data); - void(*XSelectInput)(Display *d, Window w, long mask); - int(*XGetWindowAttributes)(Display *d, Window w, XWindowAttributes *a); - void(*XChangeWindowAttributes)(Display *d, Window w, unsigned long valuemask, XSetWindowAttributes *a); - int(*XQueryPointer)(Display *d, Window w, Window *rr, Window *cr, int *rx, int *ry, int *wx, int *wy, unsigned int *mr); - int(*XDisplayKeycodes)(Display *display, int *min_keycodes_return, int *max_keycodes_return); - KeySym*(*XGetKeyboardMapping)(Display *display, KeyCode first_keycode, int keycode_count, int *keysyms_per_keycode_return); - KeySym(*XStringToKeysym)(char *string); - int(*XChangeKeyboardMapping)(Display *display, int first_keycode, int keysyms_per_keycode, KeySym *keysyms, int num_codes); - int(*XScreenCount)(Display *display); -}x11_struct; x11_struct *x11_exports = NULL; typedef struct xfixes_struct @@ -161,6 +164,7 @@ typedef struct xfixes_struct void*(*XFixesGetCursorImageAndName)(Display *d); }xfixes_struct; xfixes_struct *xfixes_exports = NULL; +xkb_struct *xkb_exports = NULL; void kvm_keyboard_unmap_unicode_key(Display *display, int keycode) { @@ -478,12 +482,14 @@ char Location_X11LIB[NAME_MAX]; char Location_X11TST[NAME_MAX]; char Location_X11EXT[NAME_MAX]; char Location_X11FIXES[NAME_MAX]; -void kvm_set_x11_locations(char *libx11, char *libx11tst, char *libx11ext, char *libxfixes) +char Location_X11KB[NAME_MAX]; +void kvm_set_x11_locations(char *libx11, char *libx11tst, char *libx11ext, char *libxfixes, char *libx11kb) { if (libx11 != NULL) { strcpy_s(Location_X11LIB, sizeof(Location_X11LIB), libx11); } else { strcpy_s(Location_X11LIB, sizeof(Location_X11LIB), "libX11.so"); } if (libx11tst != NULL) { strcpy_s(Location_X11TST, sizeof(Location_X11TST), libx11tst); } else { strcpy_s(Location_X11TST, sizeof(Location_X11TST), "libXtst.so"); } if (libx11ext != NULL) { strcpy_s(Location_X11EXT, sizeof(Location_X11EXT), libx11ext); } else { strcpy_s(Location_X11EXT, sizeof(Location_X11EXT), "libXext.so"); } if (libxfixes != NULL) { strcpy_s(Location_X11FIXES, sizeof(Location_X11FIXES), libxfixes); } else { strcpy_s(Location_X11FIXES, sizeof(Location_X11FIXES), "libXfixes.so"); } + if (libx11kb != NULL) { strcpy_s(Location_X11KB, sizeof(Location_X11KB), libx11kb); } else { strcpy_s(Location_X11KB, sizeof(Location_X11KB), "libxkbfile.so"); } } int kvm_init(int displayNo) @@ -562,6 +568,18 @@ int kvm_init(int displayNo) ((void**)xfixes_exports)[4] = (void*)dlsym(xfixes_exports->xfixes_lib, "XFixesGetCursorImageAndName"); } } + if (xkb_exports == NULL) + { + xkb_exports = ILibMemory_SmartAllocate(sizeof(xkb_struct)); + xkb_exports->xkb_lib = dlopen(Location_X11KB, RTLD_NOW); + if (xkb_exports->xkb_lib) + { + ((void**)xkb_exports)[1] = (void*)dlsym(xkb_exports->xkb_lib, "XkbGetState"); + ((void**)xkb_exports)[2] = (void*)dlsym(xkb_exports->xkb_lib, "XkbLockModifiers"); + ((void**)xkb_exports)[3] = (void*)dlsym(xkb_exports->xkb_lib, "XkbQueryExtension"); + ((void**)xkb_exports)[4] = (void*)dlsym(xkb_exports->xkb_lib, "XkbSelectEvents"); + } + } sprintf_s(CURRENT_XDISPLAY, sizeof(CURRENT_XDISPLAY), ":%d", (int)displayNo); @@ -605,9 +623,25 @@ int kvm_init(int displayNo) kvm_send_resolution(); kvm_send_display(); - reset_tile_info(old_height_count); + if (xkb_exports != NULL) + { + char buffer[5]; + int kberror_base = 0, major = 0, minor = 0, opcode = 0, kbevent_base = 0, kb_status = 0; + + XkbStateRec ptr; + kb_status = xkb_exports->XkbQueryExtension(eventdisplay, &opcode, &kbevent_base, &kberror_base, &major, &minor); + if (logFile) { fprintf(logFile, "XkbQueryExtension(): %d\n", kb_status); fflush(logFile); } + xkb_exports->XkbGetState(eventdisplay, XkbUseCoreKbd, &ptr); + ((unsigned short*)buffer)[0] = (unsigned short)htons((unsigned short)MNG_KVM_KEYSTATE); // Write the type + ((unsigned short*)buffer)[1] = (unsigned short)htons((unsigned short)5); // Write the size + buffer[4] = (((ptr.mods & 16) == 16) | (((ptr.mods & 32) == 32) << 1) | (((ptr.mods & 2) == 2) << 2)); + + ignore_result(write(slave2master[1], buffer, sizeof(buffer))); + if (logFile) { fprintf(logFile, "Keyboard Initial State: NUM[%d], SCROLL[%d], CAPS[%d]\n", (ptr.mods & 16) == 16, (ptr.mods & 32) == 32, (ptr.mods & 2) == 2); fflush(logFile); } + } + return 0; } @@ -662,7 +696,8 @@ int kvm_server_inputdata(char* block, int blocklen) if (size != 6) break; if (g_enableEvents) { - KeyAction(block[5], block[4], eventdisplay); + if (logFile) { fprintf(logFile, "KeyAction(%u, %d)\n", ((unsigned char*)block)[5], block[4]); fflush(logFile); } + KeyAction(((unsigned char*)block)[5], block[4], eventdisplay); } break; } @@ -931,6 +966,7 @@ void* kvm_server_mainloop(void* parm) Display *imagedisplay = NULL, *cursordisplay = NULL; void *buf = NULL; int event_base = 0, error_base = 0, cursor_descriptor = -1; + int kbevent_base = 0; ssize_t written; XShmSegmentInfo shminfo; default_JPEG_error_handler = kvm_server_jpegerror; @@ -1056,8 +1092,16 @@ void* kvm_server_mainloop(void* parm) x11_exports->XSync(cursordisplay, 0); // Sync with XServer cursor_descriptor = x11_exports->XConnectionNumber(cursordisplay); // Get the FD to use in select } + curcursor = kvm_fetch_currentCursor(cursordisplay); // Cursor Type - curcursor = kvm_fetch_currentCursor(cursordisplay); // Cursor Type + if (xkb_exports != NULL) + { + int kberror_base = 0, major = 0, minor = 0, opcode = 0; + if (xkb_exports->XkbQueryExtension(cursordisplay, &opcode, &kbevent_base, &kberror_base, &major, &minor)) + { + xkb_exports->XkbSelectEvents(cursordisplay, XkbUseCoreKbd, XkbStateNotifyMask, XkbStateNotifyMask); + } + } } } else if (cursor_descriptor > 0) @@ -1130,6 +1174,20 @@ void* kvm_server_mainloop(void* parm) fsync(slave2master[1]); } } + if (kbevent_base != 0 && XE.type == kbevent_base) + { + XkbStateNotifyEvent *e = (XkbStateNotifyEvent*)&XE; + if (e->event_type == 3) // KEY_UP + { + if (logFile) { fprintf(logFile, "Keyboard Evented State: NUM[%d], SCROLL[%d], CAPS[%d]\n", (e->mods & 16) == 16, (e->mods & 32) == 32, (e->mods & 2) == 2); fflush(logFile); } + char buffer[5]; + ((unsigned short*)buffer)[0] = (unsigned short)htons((unsigned short)MNG_KVM_KEYSTATE); // Write the type + ((unsigned short*)buffer)[1] = (unsigned short)htons((unsigned short)5); // Write the size + buffer[4] = (((e->mods & 16) == 16) | (((e->mods & 32) == 32) << 1) | (((e->mods & 2) == 2) << 2)); + + ignore_result(write(slave2master[1], buffer, sizeof(buffer))); + } + } } } } diff --git a/meshcore/KVM/Linux/linux_kvm.h b/meshcore/KVM/Linux/linux_kvm.h index eb1b47d..b7c8af2 100644 --- a/meshcore/KVM/Linux/linux_kvm.h +++ b/meshcore/KVM/Linux/linux_kvm.h @@ -40,7 +40,7 @@ limitations under the License. typedef ILibTransport_DoneState(*ILibKVM_WriteHandler)(char *buffer, int bufferLen, void *reserved); -void kvm_set_x11_locations(char *libx11, char *libx11tst, char *libx11ext, char *libxfixes); +void kvm_set_x11_locations(char *libx11, char *libx11tst, char *libx11ext, char *libxfixes, char *libx11kb); int kvm_relay_feeddata(char* buf, int len); void kvm_pause(int pause); void* kvm_relay_setup(void *processPipeMgr, ILibKVM_WriteHandler writeHandler, void *reserved, int uid, char *authToken, char *dispid); diff --git a/meshcore/agentcore.c b/meshcore/agentcore.c index fe691f8..b7c4fb4 100644 --- a/meshcore/agentcore.c +++ b/meshcore/agentcore.c @@ -1171,7 +1171,8 @@ duk_ret_t ILibDuktape_MeshAgent_getRemoteDesktop(duk_context *ctx) char *libx11tst = Duktape_GetStringPropertyValue(ctx, -1, "Location_X11TST", NULL); char *libx11ext = Duktape_GetStringPropertyValue(ctx, -1, "Location_X11EXT", NULL); char *libxfixes = Duktape_GetStringPropertyValue(ctx, -1, "Location_X11FIXES", NULL); - kvm_set_x11_locations(libx11, libx11tst, libx11ext, libxfixes); + char *libxkb = Duktape_GetStringPropertyValue(ctx, -1, "Location_X11KB", NULL); + kvm_set_x11_locations(libx11, libx11tst, libx11ext, libxfixes, libxkb); } #endif diff --git a/microscript/ILibDuktape_GenericMarshal.c b/microscript/ILibDuktape_GenericMarshal.c index 6c10ad0..03aaf36 100644 --- a/microscript/ILibDuktape_GenericMarshal.c +++ b/microscript/ILibDuktape_GenericMarshal.c @@ -2321,7 +2321,6 @@ duk_ret_t ILibDuktape_GenericMarshal_PutGlobalGenericCallbackEx(duk_context *ctx duk_ret_t ILibDuktape_GenericMarshal_GetGlobalGenericCallbackEx(duk_context *ctx) { int numParms = duk_require_int(ctx, 0); - Duktape_GlobalGeneric_Data *data = NULL; duk_push_global_stash(ctx); // [stash] if (!duk_has_prop_string(ctx, -1, "GlobalCallBacksEx")) diff --git a/microscript/ILibDuktape_Polyfills.c b/microscript/ILibDuktape_Polyfills.c index 45bfadb..dd9e772 100644 --- a/microscript/ILibDuktape_Polyfills.c +++ b/microscript/ILibDuktape_Polyfills.c @@ -2410,7 +2410,7 @@ void ILibDuktape_Polyfills_JS_Init(duk_context *ctx) #endif // monitor-info: Refer to modules/monitor-info.js - duk_peval_string_noresult(ctx, "addCompressedModule('monitor-info', Buffer.from('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', 'base64'), '2022-02-25T11:08:10.000-08:00');"); + duk_peval_string_noresult(ctx, "addCompressedModule('monitor-info', Buffer.from('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', 'base64'), '2022-02-26T23:49:01.000-08:00');"); // service-host. Refer to modules/service-host.js duk_peval_string_noresult(ctx, "addCompressedModule('service-host', Buffer.from('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', 'base64'));"); @@ -2435,7 +2435,7 @@ void ILibDuktape_Polyfills_JS_Init(duk_context *ctx) ILibDuktape_AddCompressedModuleEx(ctx, "service-manager", _servicemanager, "2021-09-07T16:57:16.000-07:00"); free(_servicemanager); - duk_peval_string_noresult(ctx, "addCompressedModule('user-sessions', Buffer.from('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', 'base64'), '2022-02-17T00:03:57.000-08:00');"); + duk_peval_string_noresult(ctx, "addCompressedModule('user-sessions', Buffer.from('eJztPf1X27iWP2/P6f+g5szbOK8hEEq/6KNzUghtdiB0SZi+WWBZEzuJ28TOs50GtsP+7XuvJNuyLfkjhJaZIe9NSewr6Uq6ul+6ulr/++NHu87s2rVGY59sbjRfkY7tmxOy67gzx9V9y7EfP3r86MAamLZnGmRuG6ZL/LFJWjN9AH/4mzr51XQ9gCabjQ2iIUCFv6rU3jx+dO3MyVS/Jrbjk7lnQg2WR4bWxCTm1cCc+cSyycCZziaWbg9MsrD8MW2F19F4/Og3XoNz6esArAP4DH4NRTCi+4gtgc/Y92fb6+uLxaKhU0wbjjtanzA4b/2gs9vu9tprgC2WOLEnpucR1/zX3HKhm5fXRJ8BMgP9ElCc6AviuEQfuSa88x1EduFavmWP6sRzhv5Cd83HjwzL813rcu7HxilADforAsBI6TaptHqk06uQd61ep1d//OhTp//h6KRPPrWOj1vdfqfdI0fHZPeou9fpd4668GuftLq/kV863b06MWGUoBXzauYi9oCihSNoGjBcPdOMNT90GDrezBxYQ2sAnbJHc31kkpHz1XRt6AuZme7U8nAWPUDOePxoYk0tnxKBl+4RNPL3dRy8r7pLukf9zv5vF/tHxxf9D53eRa/d6wHCZIdsvElBtA4OAoAeQDQ5xKfDi0/9Hn9xsfuh1X3fxgquNjbfCTAfjz61j98dH7X2dlu9PgXYbL7i7z++6zOAXrvf73TfC7W82mg+E6BaHw97J72P7e4efbsVf3Xc7p0ctkWAlzKA1kn/6LDV7+xSkOZmHIYh0m/1T3oCHq0A6PhoF/p68Z8n7ePfLjpdGBmsig3a1cbWRjBy/aNf2l0Gxl5tbATd7TtfTPvEg4mJhpE+61/PTHgWg+uZdG47BgIHqLaPj2FGOt3eyf5+Z7fT7vYv3sHX9jEFCqA+tFsfL/6rfXx0cdg+PIrw2OC48Mnp9y6AVntHB238223v9knw2SEaDFDtTRpyr9OLAVPITRHyGNrsp6tkkM8kkMkqGeSWCBmQ2cHRexjxRJ3PVZD7+wnIF3LI3V9Iss6XMsiTbhyWQr6SQUZj0D8+OuCQr2WQu8ftVr+dqLMlg+y3jw873QiYQr6rhfP5/qSzd9Ha3dtlS+qid3RyvNt+I7x81+r3kXo/tuFFt99630ZEW50uLD0RTpjrjwet3y5wUbRpO8O5PUAGA+x8Mp/aH3XXMzVD9/U6MUzKf0y39vjRN8bVsUIfadkDZBGq4QHD87UI9E0E6Jo+QJ2e80fAATV8bCH7ZpXU2BteOX6sIQgv+u7UOm9MTHsEgugt2aiRb1hfYzb3xhFA7Q25YWX5HwCZuzbR4C9icoM9FPqIK5WvQk+LeoXCsHFxdPnZHPgd5DZVEJHumschq2+Cyql00qrmV9P2vWqt0cYvbeg49Lwx0CcTDauqE9+dm7WoU42Ba+q+SaG16mAMnN80qkqAiTP4kvV+bksgdMM4NP2xY4Tl6yTst8aHj44N6y0DwgFU1BK2oqrnSaqiN+JwsucwmEN94pniK8dW4pgoiuOYrBhLK3GTNs0qYFUgfc1cZwBT25hNdB+Ickp2YMYXlv1ss5omSFYjkMNXkLofHCfdpwhqCotnrE/gfUgqF+9N23StwSF7Va2lCn0B4W9Onm1id8VaGrt0zrsg/r+aH13n6lqr/sJhG8YkqypeNJjJ96Z/oHt+23Udt3gpYFRQsDXA5ndhFTgTMxRgIuVlVrI7cTzzA+gyE7MaTQIt5l5HP4Txjqpc+F6RMfnke/rMkoxJrKZ059r2fGqChh30ymuVKf2fc9O9DsbDRiqiatqnMnUcmyNQSEOO1HV8VAxpPWWqObFXVNE+qNeH5tRxr2OlbqKvUOdgrIHFUJPO3U1sgmlDuvEVZqfIPLYopJK2WUUJpFsTWOrwu2UbHRvsAX1i/a/Zs4yi5XfH5uAL1c2g35dgQI2tWdGyOFpBU8kCKD6KrWgGqegzfxlr9xuZ0i/bpBpM+0dngXPvoz0Um3sQRGMoa+xZ3gxnbps0b4q1Uj2x3bza0zW5s4HrF+n1MQJuKXpNa0miM7eMfdeZ9sB+s0ctZSn2vu+cnFA5HgoH8bk2gsrkBIwfrrn8Svm4WK4xT3XqV9210ELVmi+S68waaqnCDMdEX9JgijYo2nWOW61BEQQzoBZvN9Eb/AhKEZZMIHoT/2mCYMutEcjKWRBYP858YlCfwsCxwYr1iUc7gzY6difFfW6kbEU1gzAanJpKig6FNDqamfZHJvyrNVk56UIXSlFWoWCp0rIgQWkZQUSUKX4A+sZ81hoMnLntA7NRiRcl3n26/tNop3l6BkePfsoNknDFp2dQqz43npmv9eev18zXe8/Xti43Ntb0F5fG2nD4bGs4fN588XzrVQy1XLsmszn9pW682thqrl1uPdfXtga6ufbqpf5szTQHl5dbL17pr81mujmpeZTZzouh+eL18+cv1l5ubEE7L/WNtVfDza21weYr4/WzF0ND33opEw1cRPd8mCgk7tMq07CAV8Nqsm2wQKhaG/ygegb+7o11w1ngN+DmAxGyg8oV/D1Ado1+JPxxbHqmT6GdhU2hQD5Wz5NsE+lyd6J7gEruokcVgUtZWA4jV59Wt8lGXQ7YYt47JPiuPjUBsqmA/OS4XwDpPVCXBz7qHttkUwF61D4E3XObPFO8j/TTbbKlgEETkGP0XIWRRecnQv2FAnDPmepWAPRSAcQnks44gL1SgU0sMO7eza2J0Z2jLgKwrzNhg3FVTQGDEse1qZoDBgqzaszBAsbha6rmgIF+0F0Dna4MVjUfDLZlGOgeRUDVpASoemCSUURVUxMi6jsDZ4JONoRWzQ+ujL7FRkk1PQfOyLEDINXkdOyBMwUifXcNqxYBVTNzNPdHjgC4qZqcoMZ9WEYMUjU3QZURZPbU4JJGqLxFwsFUUyKAta8QUDkljj20RkF1qqkAxcMy6JoKIFUTwhvmVPPrFsIq58U7BnslNOEQ9HVC4UizYMs7dhxf1A7ZEy1bJwQpNAfB6lr+tULFDTW1lDIolG34zrv5cGi6Wq2Bexhmx/Zfac/r5HlcWgTNtgwgE9y30GERe+9dZz5TNP8RqMTHet+ka9GxFsFvkdRVA68QVyRUdpUmdKQObJo8g/+eb23VQQ4k/y9BnCmtTwoprYj1lBpliu7iPtlI0l1ph2SGniZHsrFnuuZQA02bNa9EWoF40D4rLU43qmIngPazzYO2VmNVkm/h3HBnV7pGyaNY57glqmV0Jkfp5xYCxUSuJdIGR6bPFeGjhc3EqLiMJK+1WQFTC+qw55OJhGxt1kLmYmtubG7JSN6gwnnZ0tgyE+8HzAedUw9UkiqTWurh5KtavaTghVtMV+BZhs92nsqXpV71OdvL2lC9L8B70iWjvoSGmWBUacqNuDoojQQpKGVbE20cGcDU78sM0n3dmrAt4n+h4ky4q5dY6C8hT1llcT8VqzDOLpImnzaui7uAdTYWlDPs7BRgZkmrNPKKamMZ/0p3h9oBhOPEthPplvIs1rPUIpfMIpBIafKIDY7EpmU7MhHnjG931mmjdVDJYwS+kkZQna9HpEslT2YjApFnjoFYiZqJp+k9JXqW7kkxDBLdla4KFJWuDS+CLYAk/0/Sf8rvgLIyRC1CHDlePcX36pz3yt5wBlXGfRX0giFF0tsYnNbFn4W8WIhd48ID1YZyPI618ETqSoM332jRbVbBJ8swN0/6+6+Cbm8HFQlvcAFs038zFIKbvPWbwUZiFCVfWcXYT2IHNcQlrUeDuD/WF4G67vPImoRCIIHQvIgx6PAwWz9g1L2EynuJJtgx7Y1ZjOOpFjJulmRs+eDaSHQpWJT1OBbLUD0ld4J7y+hXzUCDiYHEVItbfw2581cycjBaDP+AoPjfjUR/Mvii8EoyN2wZMYCGjsaGVrTiRG2XDQxDS1JrSKPB3EVbW1q8Z0XJP037OYT/QPV/MKoP93wSpB9y8dRY3ZrCEqiJ/J/WPWDb7idUYxMCdYKnOR4LQdELhyZrV1+jM5Xex7IMUHKv9vkHFAs6S1q161w6xjWZOKMR0JqFOwxyu1KL66apfsJyQe3HTtuTwWMtc8suFtkiW3tzVD/jDu+G4Auu5Sz1vcCUFFFjD+8GscixnIna7tx1TTvmyuKPtMFlwR3Ob0mtA9/OLMBmCe5D9cXS1kWK56RDMzTmU6LmIKBWZy2thLOkG8vlKWyh5HIVtM94xBvVLy3yD4Z3hg74hjx9ahXzjvE5ogOSENQW+XswpMEk8GnrUd12h2yRn0lzk6ADuFYnhUElKjGi8pkqxSEj2aa4ldB08fO5IWy6QH1Ct3LR2yK4saLuRi0cH7aLp2w+9JzE9ulOy+DyitAdCbJVUw/AuQQBXAUhEjsk2BesqXyMnxsCz1QymM8N0QxXc0AJQqyRvZgbbYkmBF4maUTi22Ss6VSo9hya/1zMOEpL49j6SCs8LOqzYZhDy8bwlJnp+tdcONdJtDv7DQh9Mgejzxs7C/b0yJ4EkDVyI+NqwIWh4OAyFPYKx6tCGYh+YWVPRhPnEmjuwnYOYWT0kflxPp2p2fz6OvlkEpsfmfBgHAiYzzqZssJkBqXreM6ADE1/MIY3C8s2gEmOqWmY5u684AUWFGMcodgaf7eG7xRBChyEl7bNRaxC7RseR4G1tC0/hwDjm66nMdO5AORBIpmt0tBR88ryY2GjA8cww9BRVl9IRpmhdZpYYrywYzGw2UggdAyJcUEfotAadHqcoub0vF9b5sRg02w47NgPhl+PEeLKJzSUGVQ4Z0ZmsGBBdTcHc90zycIEeLvqk4UOAFARiswCMWdSfIauM6VtijRQZcFpVdqmPmdtQv+IPvDn0Ng1ntGhhayB63i+PvjC49nA8pgP8HyS7ou1UooOQaCjY2diAH5SlPD8DxgwU302dlx2PGfuYT/ZkmyQzhDxob22nUUdf+DxJwMqx/hirOATXS8eeRkNmwUDZkER373GymwcmmtiTaemYQFnn1wrJjaEgGn1TL8T/NQiGvHMybD4FhR0sQtrmY4RoD7Wv5rJFV5nHbRJEOqH2NMRGJjA3sLucW7jqfe6EDVx7eB6Sj5rZEe8xupA+q6rTiyluWjwiTXJwxpptNIHOqrpl3nULEFKHgIF2qlKhMraxfCmlSOVFTNVEj+Mg1o5ftIgqwzE1te5pdsAC1NTz22DSmr1MKvfs27KdHn83DBtJqXmF2Px/HeMy0+9UT6f9xYWSmMEbvBKiq/6AfIgmfzclsMnG1zACOlTSXs57cbbTxzFymg7+IjCzQwMMlROPdCdgcXbAh/EyfMyUCyIavBB/kWrPMUBmNABOE8qBObU8oVDK2l4JU8SPynSkX0uQXx9yYFLDTM7x/anGWjhfM+9G2p6YDFnpKWF9vfLzg8di/C42Ao6lDFwWUUDrhI/+fudWApYZvp84hcYO1FcVNMHlU9Pur90jz51CcPonLl5BBRXSTHxE84FkA+tqRmK1bWpY1s+7nNyKvCuaBDwQbv9cSWUkEQ0cZx6VQizai+6sAQ6XdBOWrv9zq/tO+zBigec43/XuKcOqt8e/1WyjRi66dP9BZBF9wHj34EnKVDF5M5lvjWIdqMW8f6LsXkFkwL/VlPbKqpW8ZAytMkq4G6gzY16/EGOv24jaz9T9gn4X6wR9F+/iDXiO8wdqfEurUzU0smSWypFkSkwqcne0vPgyYErXk3BvsX6uFECzeCTs3D0gTHApd/aLbR2kp8iayn5oV1p3l1XuGX4ffuzeXf9+XDU/y59KaBnLlN1tDqzTPY7WKg5w3upYx6D6wPzqzmBYZYu5xKjt9yQSL0ED0wrZ+oMfnQGFgfYGX94xiV2p/uHZ1tCb/Y6h4ft9LHYIp97wLwKVHlHFmi+EagqnWgw5heI547BmFEMd5GmB5lY9vyqSn7/nUhfD13TvPQMSf4Q+f4iSxNTHevegTOy7F0fGW6ua3Bk+ttiwpPCbsEowkJoEQ+g4LmLdG4YAUjtbaHxHmNrYohbgfTBxSw4Y90wr8zBvjWBN+uXlr3ujaGbp1X4c65aArSGhucbztyHPxgDV60WgUWnKzLz+ObeeG5/CX1MWN3THUIfRqJDtm2XasGy2REOrbIYgyyyPAx7sqCZCfmd6IsvpPoNKAOMF/LTJrmpntm4z3hmV7IrXuiW3wZApVGRnrSd1Ag1oBtTdp6oUlHUkzG/5ZZMFjlXRsb0xDIq9SQZZtOtIrxFeTAoAJhGYQnwlYbDKSDpiClCLlaw2nM6w1piQy+OvBwyQ6GgkVkLQz0qIuDcMjwx+5bscwfLN6w2tYSLrNbUSi22SmONmq4raxQfL91ogWYjBgHUjnvquJ0Ok/U7gVqrZ2d2lVT/p0qUDEFRWcRdSpashu+Gluv5O8AaMtWOrBooYxtqlW+Aw9KV2DssVdxP6HwB5oEM439uUyHmk7N2mm+sf9hvMGhu6Yq+LV0SP6xXtEen1nm9Va9s36ZX+GHjTSp/887O2D/b5Bv8i3sh+CN4Wifwj2F6A/HhDTymU14nrdNn5/hvk/77/Px2WHE6qpcmpEr47mZpIg5I8Kb82FZu+LIr1XIgwQs0livF8RNLWpP85FiRjOn/R++oi25Tz9SSHDbPngh2RjAUrqnRiliiHmt4rUHtdSpRwLrONPAzdHeWROZ/l9vlSYXyxWq+bzLqlhplrPHSsmqVjUcLJFRlJ5bnh2kvk6IrkERl13DAzU7LSyDDnCwjuFYlapiE2VxawiwjWBLiBE9dAvZkOZGCaqfz5XTrfAeGkYaiOrYPui3mGViiukguoTQKwo+peIqJpDBwV/IK45uDx0c29jN4BRprDB4FGRAAHQIqyPBvk//dXEqYUXoqL8CqpQcrGKnz8sKygPEYlYyJnrsRPsFRg+btRBCtJgeGHpgQDkvQZnkSYHYwAkgYDRuWBpi+xjTB8+BUf1blmTIQK71/so/apyD7uaOG/Pu/s94LaZGXntbFGGWmUN3brMoKVIgflmAA7XY2S86s0HYp7+cpFD1voD4Lk2SYV0dDrcpzQpFD3dZHplutkbdAHtQyDwqw0/wgQkfGtCp/M8HrFZRvPQNerTbOia6Rju1r0FINKHlq2QU3FUpsKAROnVhjRV3LRWKoskEyXiteyXPbpB+uWOf7rv6IO/VDKBuLJE/S+zByzRmpvLedqUkSiwmdCxgCVZGoeWv724JL81meS7OAIUTPw6hdl9UqsjeNef1CilYUqAVrSnBd55eRJH75a1ObGDAnNnZbcgNGnEla+L1agddAYZEXp7v/hot4rr1bgDDovuhOQU12CErg041/0KA9y8bST2mWE0aj+PYN3wUiN/g/2v4D2f75yPaumOQBvYTpgUnKqC2oIHVaQ8zoLL4LD/bHkxewJzQOHG3H7EPqKyTxItuKd+f8yd0lOKsgOwxGBcntrBIjsoDGMkgs1yKMdtWUZCA7xIpF3u6EV7BE6VGS+lxwxD7oBguwFjpVxSNdZP/opBsPgRCPg0ffwmGnu3EXRzYLab0YYC7HYBctIwUG4p5VtEHP4oMN8JY0CyQQiNuPFQztwJNPJIy0DY8xjqyv+GI+k3KBkJjjd8wUidtlo59egD9g5XyPxXKX3tHc9XlLn2hJP2gJ3+dt/J3L+DgL+TVv7ctcgf/yD+mzLOmnLOSbLOmPLOeDLCRllvAX8uyl0pgFme+wkK/QS/sKw3mWaTpxHl/tdfYAn7dUjCUchl7gMJSMzgPfXVorCrkuZtkIuC5ZmxGWFwWVJDqnnx0LMCHVGqpKgQJPYXbkLJobnYUYNaMuzQar1GZWqV2ILRJZKIFyUxt420828DWGtU4zilQie9aOjNmCdRaBK72ykypVtnWSr0Wtr5M+BtCRhY53nBLW7yCTXJ7WxdOxBJmGPJinuS3XlQppfvIkn5lFfWtKCypCsJbU7pZJX0ozPJBQM1mYLHUGjA9eiou5HYIcIJiMQh/pVv74QoXSIa5HdSw92k+fLjvWnunjDQ1AcZkKfZ0838i0T+MEvYIUaurM5Q+CoJQCrozEDEItcefmSU4IpcxoS3PAxdjJFBHcLxloTN8qb6g00EEa6Ewa6NjFUOfWRb1WGroVfAPdUNPfNn+uYIhYpRYohYGS+AYoNCx/U8GfZ9lhSDkOpWWYijqwttDgriCSZIkIkpKRI7eNGFFaUTmxiIUjRFYSGaK0qDRGdk83am93BGd6YZyJKmIyS9UpF4airOmeW3OZuGcGnxRV6RSwhQHzAlPKB6QUCkS5RRBJlmEYVi15ficGYtjh+7DxcotgwB8SgXgv7D05IsVsPnXZ8gxxWdtPXW8ZWEAA2u/uR21uFG9sJRzBKrKDpdghsxShT4rYGb60yRppnodZXoPMnpIm5DlJeUraZraSJd8+2eEn7XLVL2mgnqJbDKcMbpoxivgJ0xN/Ma8xJyTu6cghM2KSoNAplD+nCYBPwo2f4HFdTAoMD+ps0W4LiVXn9GaMaLdQC8rK0wTjp9gdWTQuj2gFs6clD73FfyqzxBZMEVtTGT0xI1OB2uCygWko+Sk7yVUHSRtXbCDjfFv21lko3oYo0xY4mEUvOqLVf8IS1HyX1ASiEShv3Z3b63NfkjFWXhcVSczyjwklMMGSw6jAL9W5pJvmVgf0buFzKlRFju+pSB3KeExFyF7aaCwwDrfY4lSgktInMtmuwE3Y7ZTpCAT2XJNm146cO6nk+MHrwXCUImxMIoFqX+/aHgB9m/5gnao3yDXwfaQfNZgpV1WY9eFla8mMxvgRksoDzwY8lAnCWRV4YNiZzKf2RyYjhiNqPFbPfLwHKp5jk5VQTQs9RE4hTjfOKRvBfB2HnW6VRwY04Lso1TlwMyNln6LO1j+jOlv/XKLOABshcjqoTDj1HihZRVUA2c0wFFqMZUi5GJkPBToR0WDgVsn0L96FC/G7b+18d59lpKWC/CeJVRhYDkhk0cla1MabOztnFU7PZ4Iq/tMmjSYstWsio5pcVZfFtf+crxOT7aSbO3ktCE1v64k8jz35AfR2P6OtYtF7OPvP3u5EoaRDgu6fbfQA2egY+qkJ/z0rTwbpEaa+O1kGB7U8EGVRXS4VQokwsVEk0EYKaGqBdGAOxYl9HmCxLRVKMU7NmfNp+AD1/5A141BFn0y5XfC6rQuezUAgaHiQlt4PZPwnI+O7ptymSLkb5yldYDlypQLnJEGy4cMcNpyf1uRBObj1SkpFgAcr6SxYSiiPxd0RvKg72CR6Wb+sV9b5sYTLU/38yU7FdugEi6oDW2w3Z1XmoqzAQqzgv/UgtPdM2Gc8/Zt3jqsU/XAZ234F1Y18rxCYK7OJPoChqJ9X69Xzai3zqrFbXkX3sB3+R90OL+pBrxDJUZ7iZRX5bVQe9PCEEG6Csp33K746+aa65U/rlZnv4SulWEiN8ZOlsjvJsATOcLWz06zJG5e5KxVd/SavQbm3wDdJw6CCsqW5UVyu3F3sU6xmm0E8UBMsYBarJhxn2JB7E3JP4xQnEeUJ/Gzfeuz2SGSzKquwpFsvwzeegVS+o+Qh5OQh5OT+hZygtGS//m/9v0EmnJ2tr68wDCUZNkJjSbysWBIh6OshhoQUZOXxUNWioSN/kKgTT5XCJH0koVfuSEI4vg8hKw8hKw8hK3+MkJXUtkEshgXzHRWwKlLRa+vr5J05xOsuFybx9GtisxvcWTZjvMTdsUEZMf2qR+iuMb041sSs2HjPJpQDSJ283zuUH9hApoi5H4LLgmk6YInzit9cHXIjnjB9DZ8DMwJV9594hbAGFSS7SceSFuc7e2gI0xt+r/S5P3Zgtq+jZzzzer5hjNVSzNN3iWfMUmw8R3hqYj6j4+elR80m/wwGjXjO1KRppOuYX/hSv5xcsytSf+3uZliY3yPR9h0z8VjD3zv74d0YD/KaC2U9LGlEKIqUzna4rDGhKKvOcrgSo0JdUVnDQl1T2S6QuzcBMhvPzWNYRtwq4EsBF8l3WF4qR6VyU+zeMkthkYzpWRkM7yRzYUL1P1lK9cdP8Vx/Gd4o2n2jaGq/oiIe+59Ry5AO1ZOdIIgnKemF+B5R4IdBPuqqM3qKn7QCJle5gs8tM94FqVO4Qsa1MVhTTkAFKzkyGvRKoljFY0iDr4ldIJi2D6C77DsTgwYiikF10Qscqx+7G5QB83236NEahEXDLMBUNp8Xt48rKmCGpCPS0JccZOVJREbyx8gsHuYwmsO5ehKby0+idH9BSO4q7FAo51mZhAnD6qsh6kVSLwW08d515jMJcYTPtdEDdZARjgYljtEfjjhGAXGMyhHHYuzoU0skC/bkR+/+/0BqYAPwPdi4ZKV+TMQY8UeaM8OfXvasUIekZPjYzYiafz0znWFYVb4PJfuOtoD0OvZXfQJUh9WDKWgOrKFlcmpkTZKoTYXCpbrrjV7gV7Xn00vTrSrwCHodZn2kDSekYogBLo6K6vqxbDSYdl4KDd7qLRp16DklVaNWNLaNMAMjrIIsZBpi/j7AKuugSLwByxBj7UuNO7WLchoU28Iay1s0FA9Y+Jq84+w14lByc102Rfc0S582qH1TplNdVSTUko0I3gWPrJlkzSEzoCn4QzO3w9/B1GBSjM8U+Z1mamXOO+neCpXXom8uJ/+wNLPH37xKXbOe7CQyeSQyeJxXSkfyJYR1MmQkw6ArcAo0x35ktxiYyYgQZZvaaYoGRRMyKayGlm207a9tG/MICRJLfF5MbF26zheqmerAcSSbC4qTW/TyPCYuRekZtpkafiwAoioZpoyPPyeeIQ2FR7KwkfxBzOoFH2T1+bOJ2AsYvX3XmUJnNGz61DqXO4Koi+ozYhgwOHpaNYmrAl/8WEMN2z6Nlz/9fH6+3LnhdD3QLUUL5TjwUqcWgynx3blsRiIw9TW1pQOkUIjRdosuO6J9yzsLWcoTlHOaWKJzRvSW0DzjhFgkd1aKvIsfWFZ06w4upV1+n+y+JUbPaC5xag7Hah1F5YyZtuum/dVyoZ1gY2yjiv/6IF6pQOUytnLmV2JB7d8UAhb9um+b8C0ArFfe3IQRvJHg3REFrzShVpCRx5tfQsdp0c2nzErW2DtqBsfyaoFULhp3UDb9lsSzWy6jw7LSHD+qHAhpqV4AhzSbkTQh4Tz5set/oVUcLSvE2/Nhba2xEKFZ6DNihkfsET+X+lNz56xyBgT70yb/wr1KG3i5BV2K8PgM/qF/bfgnckOQQvT6b/8mH31Y71LNwxVOlcspM+dse0xV4ufNC9MmYBWd1rLCY187SgMNtQwoxA8o4remTJNY7tCXQsWVaLfoTa9j89lCcc59rimreJ7eJfuzu9XA5MM1kXMK5mdSWdOvCDXCcO2krURhfc2DqxVSN7Y3f8SRyPC8Y5lTu/x8ZHD20T7nq05C1PT6Azv7rjjFOqMcQG5iTGzVWsP2TFxty1kDdInx8qvSroNqqQ9KsnQ5OBdbclozdHeBSW8Z6LfEmn+44CRRc7SCLb5zJtxpEi08rug1+VngOggwEHFQc3iGy7RpiAzlnGcV7SzUBPERO2S+9NZKgYtQFOGcwYRJMvAUFRPBRlpnT7a91tn7a2+9WrL91ohgNuu4ZRWRC6zaESUHTN8B31jqDgaML5CE4K89nyapiD0NnHbfIcFHYks+SRP3ckM+ZoXeS8r5HpcSGN5gQho0RJSsn9DcKie29a+5CUtY1C+SNIsh85s7O8K7mqhyrIJ/KYitONcCHLGmgtn7i3mN8FPICaWMVbAdX5HaP8c5dU9DFx7WUWod0RnxyEegV929DiSisJxGGctptNLldPtbLUps41PKvcVaSYVuLLdW7ns+hx+ogggZEXAP8axRvQODcWXsmyzDvxPpVvMItFB0KoXMVHGKhI6iufDXJT3OIdcwlSRXNdYDI0p0F3b3ezhme9D/ge+419L7SDdvodWWzXzwY3kiDk902eQtuGI6c94K+eDccylB4iRTkuRfqg38B6Ui/mWzjt8CHfOWdFtE97jbFE93ncupTIDFSlx3kR+8njoRQh25nIro/qbE6yccFKGtJw6KSAg9nvIscn2rU9vEMp5RhKTZ+tifwEuIp0tlOdDkJi+tNcusTaXtu33Gvh+0iO4bGSeH8C9HxGm6zU3ktywRW0Zfv5yIFmWOUPA5uDQGaRlitwxK6vDnXlLxCmgTpkxNDRn6r5ANuyQ10om6npkygpRvKMZ2P2nR02ZYpC5PYY+UcMpgGduVrKZYPz4L+6JZ2zOWobtuRPGfQ0Q05WZoeICPlsVFoobjLhQGib2k4RVIBhv16Gm0+mrqfSjJOJxi9ee0/oIFLAPBsZikQLFNIFpl1kKXXAWYewdgjEkmXwZ8IMZGbp3NM2AKE53KutMq/fJnZQwl1zseBA1Xc7T1ydhArj2BIucJEzMSGYWEeLcJ3zKbJvEbVuRQ4f0qydeeb00mkeUOJBWOTpP8HF5iQsCM6th6/G4WJFuMyFdiVuKeFvzwoCTVNnGxdPzyEE/F4FpDLXNs+a1AT6JrgWKEVGAMy+95F0Eo85oixcDkKT7yq2woNkUus2H6UnrF88tsMKta7Loarl9JzheHmMm23nEqFpb9bLNawzQrBxj/WSeH+uCoVyf7rmm+6+2x0skted+PBZjDz7vzZeIwoZDaVhfuzfSF3UdB1ui3jw/vZTbkCo5Z4EJaF24/xbCyq6aJwZbw56xSp9ch5HmVklXfzlMKZJglIwCvlJQIRD4UjbM5eAB6CzI513H8apY20DMnQ5GO8PcdOIMi1R4W39r8DyDHk73OCaRYQQRFYmYs7xgmT5wb9iRjdmJ+bzaTLNVTupmQK1FY055PTRdY8UnSMRh/o6Xjg+iBE9eZWp4p0gR/FKM9CopjYi6CIlo0d65Jb/36rO4eUzAvANCZfOVXbiXPrYQwn6nLmMKI51hiUz8DyLFuG5O4qz58yKWAEqGZgI3EwhbdrqKaJOtWcBu3gJKCOCQ5baVosQHQVLbADCOvmR2ACAhAYahHUBJKwf/D4UlISs+ZuwPEhmPBF8uvlJ+FWWZY4Cc6qUQzIrAtUNfzkuD+dBZyyvh1UGGTic6jcGbv6A2nTLeIlIvMhQP4sqQ1YQXJJQ34AIpCA3vOVAdsfpY8e4rnBqp4iU2VZkaMAALVVqJXPGEDdAoNMU9Q9BNnCYYjQ7uIjxArmh6hcLB5gh5hitkX5Q2AMD7AusPyouoUzWC4ugQeBwXxqUhBI9PvU4NeQ84Zoxx2iVeKFqyQEjgAnyuUkKLNrlk7+MyyDfPqaEj1zCgkieYHIljoFOwkdg9X5IbJqNgKKxae1WKtYAKU+9cSTe8Ky2COA5qqNebLSCCFZSJFJdzkYkB8Ph8/mjrGHIwm82rmuL7HWTtSOL8O06PV/z/cqWl5', 'base64'), '2022-02-27T23:30:32.000-08:00');"); // Mesh Agent NodeID helper, refer to modules/_agentNodeId.js duk_peval_string_noresult(ctx, "addCompressedModule('_agentNodeId', Buffer.from('eJy9V21v2zYQ/m7A/+EWDJXUOHLWDQMWz8NcJ12MNM4WpSuKJiho6SRxkSmNpPyCIP99R0lOZEdOXGwYP9gmeeQ99/Yc3X3dbg3TbCl5FGt4c/jdTzASGhMYpjJLJdM8Fe1Wu/We+ygUBpCLACXoGGGQMZ++qp0O/IlSkTS8cQ/BNgJ71dae02u3lmkOU7YEkWrIFdINXEHIEwRc+Jhp4AL8dJolnAkfYc51XGip7nDbrU/VDelEMxJmJJ7RLKyLAdMGLdCItc6Out35fO6yAqmbyqiblHKq+340PBl7JweE1pz4IBJUCiT+nXNJZk6WwDIC47MJQUzYHFIJLJJIezo1YOeSay6iDqg01HMmsd0KuNKST3K95qcVNLK3LkCeYgL2Bh6MvD14O/BGXqfd+ji6Or34cAUfB5eXg/HV6MSDi0sYXoyPR1ejizHN3sFg/AnORuPjDiB5ibTgIpMGPUHkxoMYkLs8xDX1YVrCURn6POQ+GSWinEUIUTpDKcgWyFBOuTJRVAQuaLcSPuW6SAL11CJS8rprnBfmwjcy8GWKKh6nAY4C22m37spIzJgkx2rog2X1yiVF8fVjsDOZ+oTczRKmCeDUKberg2b4jLBbCRf5wjraXA6YnHNRXzdDy+X6wt36dIUpmBCkKuK25RnX4THTzNOpRMtxhxKZxgeMuED/d0ZpuQ+WG0ysDtzRaRZciGR5REpzhHun91RVafqDHp0oujtJWTBEqU0kjJI7yMLFEUFyf0P9Ng9DlAQJk9B40whaTgcyplQWSzL9CKyYBwEKi3S6EeozXJ4yFduOq1OPckxEthXjwtoEdL8+Jd1+bKPzrL82zkzI6NveZigoDt+/2YxEtwvvuFQahjH6t8DLWiW/D1NhilgV8yJhjv/XGLoSKeV8OmKWKJRFRJ1dQ2o0z0jxc+FqOEb22zPn6XqDbY0+eEHejK9Jttl/klGrcd+83JxhO1hi/CvyJNldXcNS4XHolzfBq1fFbCNsZfpZjgPflHK7R6j09mwHD92/XIbwL+swwJDliT7aLlVdQKhzKcCmbwP1voHC2RQ3CFzQEtn65dw7pZQwQh7KGTUCI1vdz0PbiPX7NS/WbChJfxvnNxj8DLOYQexyIvIp0iulbHUSI9Ngl6ZDK2p/Fd/MkW4S9NgQ1HVzWfFN7aLmAqfb6qVEMA5WChpDXHiJB8ZJ9Ta4RfIWlx2jYsaaMtxIKMLqG59/JjH39Ozkk/s+9VlyTo8ZLrA4XS4PcylR6A8K5c02tirUPN2bx+YJZpfRfSyTUreboIio4f0Ch7vXBGkq3Ba5f+Qol0QjdnWbinmobSJZy6ueTNfXFxkK8Ir9rcxiXi42+YuuPewZx8HPRour8glNVIWyt79Ps6/nma0s+8I5Mwy9FCHvQ8kmbijTqb1m/JbgNfvg+tqi50XNuM/0cUPSZTYRlyt632nb+pV+/pVyYVv7j4vfPix2TS+zJlQ/P/5gPWHwLU7a0WgzKjbYBLolgPWxyVpNY0sreWFrRaKLZ8x7xrQtN+/eZ+o15NBDovKRdU5kAIOICtTqNZ1t8kgzl5tRMEPJvHV2qpYOpkzQk15SzKtfLq4osuLrRkZaYTXExUqoT4WKOjT6eVmJnOqw0ruqQdjf57tTBfWL6vxnfkP/0jJTIqYL2U6/v/lk+/rKroyqqRCPvappPJebu+XB5g33jY3XwHjovNM0yBMkM+nvtlbr3aO3ue2qx6b7IFoa1W79A3i885M=', 'base64'));"); diff --git a/modules/monitor-info.js b/modules/monitor-info.js index c9bea02..0b2a8ce 100644 --- a/modules/monitor-info.js +++ b/modules/monitor-info.js @@ -251,7 +251,31 @@ function monitorinfo() catch(xx) { } - + } + if (!this.Location_X11KB) + { + var xkbinfo = getLibInfo('libxkbfile'); + for (ix in xkbinfo) + { + if (xkbinfo.length == 1 || xkbinfo[ix].hwcap == "0") + { + try + { + Object.defineProperty(this, 'Location_X11KB', { value: xkbinfo[ix].path }); + break; + } + catch (ex) + { + } + } + } + try + { + if (process.env['Location_X11KB']) { Object.defineProperty(this, 'Location_X11KB', { value: process.env['Location_X11KB'] }); } + } + catch (xx) + { + } } }; } diff --git a/modules/user-sessions.js b/modules/user-sessions.js index b71afa6..5379fd2 100644 --- a/modules/user-sessions.js +++ b/modules/user-sessions.js @@ -845,7 +845,8 @@ function UserSessions() child.stdin.write('printf "]";'); child.stdin.write("}'\nexit\n"); child.waitExit(); - console.log(child.stdout.str); + + console.info1(child.stdout.str); var info1 = JSON.parse(child.stdout.str); var sids = []; var i;