diff --git a/meshcore/KVM/Linux/linux_kvm.c b/meshcore/KVM/Linux/linux_kvm.c index 05b385c..1c6d335 100644 --- a/meshcore/KVM/Linux/linux_kvm.c +++ b/meshcore/KVM/Linux/linux_kvm.c @@ -95,10 +95,11 @@ int g_restartcount = 0; int g_totalRestartCount = 0; int g_shutdown = 0; int change_display = 0; -unsigned short current_display = 0; pid_t g_slavekvm = 0; int master2slave[2]; int slave2master[2]; +char CURRENT_XDISPLAY[256]; +int CURRENT_DISPLAY_ID = -1; FILE *logFile = NULL; int g_enableEvents = 0; @@ -147,6 +148,7 @@ typedef struct x11_struct 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; @@ -416,7 +418,7 @@ void kvm_send_display() char buffer[5]; ((unsigned short*)buffer)[0] = (unsigned short)htons((unsigned short)MNG_KVM_SET_DISPLAY); // Write the type ((unsigned short*)buffer)[1] = (unsigned short)htons((unsigned short)5); // Write the size - buffer[4] = current_display; // Display number + buffer[4] = CURRENT_DISPLAY_ID; // Display number ignore_result(write(slave2master[1], buffer, sizeof(buffer))); } @@ -437,66 +439,17 @@ int lockfileCheckFn(const struct dirent *ent) { return 0; } -void getAvailableDisplays(unsigned short **array, int *len) { - DIR *dir = NULL; - struct dirent **ent = NULL; +void getAvailableDisplays(unsigned short **array, int *len) +{ int i; - *array = NULL; - *len = 0; - - dir = opendir("/tmp/"); - if (dir != NULL) { - *len = scandir("/tmp/", &ent, lockfileCheckFn, alphasort); - - if ((*array = (unsigned short *)malloc((*len)*sizeof(unsigned short))) == NULL) ILIBCRITICALEXIT(254); - - for (i = 0; i < *len; i++) { - int dispNo = 0; - - sscanf(ent[i]->d_name, ".X%d-lock", &dispNo); - (*array)[i] = (unsigned short)dispNo; - } + *len = x11_exports->XScreenCount(eventdisplay); + if ((*array = (unsigned short *)malloc((*len) * sizeof(unsigned short))) == NULL) ILIBCRITICALEXIT(254); + for (i = 0; i < (*len); ++i) + { + (*array)[i] = (unsigned short)i; } } -int getNextDisplay() { - DIR *dir = NULL; - struct dirent **ent = NULL; - int i, dispNo; - - dir = opendir("/tmp/"); - if (dir != NULL) { - int numDisplays = scandir("/tmp/", &ent, lockfileCheckFn, alphasort); - if (numDisplays == 0) { return -1; } - - for (i = 0; i < numDisplays; i++) { - - sscanf(ent[i]->d_name, ".X%d-lock", &dispNo); - - if (dispNo == (int)current_display) { - break; - } - } - - if (i == numDisplays) { - i = 0; - } - else { - i = (i + 1) % numDisplays; - } - - sscanf(ent[i]->d_name, ".X%d-lock", &dispNo); - current_display = (unsigned short) dispNo; - closedir(dir); - } - else { - current_display = 0; - } - - //fprintf(logFile, "getNextDisplay() => %d\n", current_display); - return 0; -} - void kvm_send_display_list() { unsigned short *displays = NULL; @@ -512,10 +465,11 @@ void kvm_send_display_list() ((unsigned short*)buffer)[0] = (unsigned short)htons((unsigned short)MNG_KVM_GET_DISPLAYS); // Write the type ((unsigned short*)buffer)[1] = (unsigned short)htons((unsigned short)totalSize); // Write the size ((unsigned short*)buffer)[2] = (unsigned short)htons((unsigned short)len); // Length - for (i = 0; i < len; i++) { + for (i = 0; i < len; i++) + { ((unsigned short*)buffer)[i + 3] = (unsigned short)htons(displays[i]); } - ((unsigned short*)buffer)[i + 3] = (unsigned short)htons((unsigned short)current_display); // Current display + ((unsigned short*)buffer)[i + 3] = (unsigned short)htons((unsigned short)CURRENT_DISPLAY_ID); // Current display ignore_result(write(slave2master[1], buffer, ILibMemory_Size(buffer))); } @@ -534,11 +488,9 @@ void kvm_set_x11_locations(char *libx11, char *libx11tst, char *libx11ext, char int kvm_init(int displayNo) { - //fprintf(logFile, "kvm_init called\n"); fflush(logFile); + if (logFile) { fprintf(logFile, "kvm_init(%d) called\n", displayNo); fflush(logFile); } int old_height_count = TILE_HEIGHT_COUNT; - int count = 0; int dummy1, dummy2, dummy3; - char displayString[256] = ""; if (clock_gettime(CLOCK_MONOTONIC, &inputtime) != 0) { memset(&inputtime, 0, sizeof(inputtime)); } @@ -592,7 +544,8 @@ int kvm_init(int displayNo) ((void**)x11_exports)[18] = (void*)dlsym(x11_exports->x11_lib, "XGetKeyboardMapping"); ((void**)x11_exports)[19] = (void*)dlsym(x11_exports->x11_lib, "XStringToKeysym"); ((void**)x11_exports)[20] = (void*)dlsym(x11_exports->x11_lib, "XChangeKeyboardMapping"); - + ((void**)x11_exports)[21] = (void*)dlsym(x11_exports->x11_lib, "XScreenCount"); + ((void**)x11tst_exports)[4] = (void*)x11_exports->XFlush; ((void**)x11tst_exports)[5] = (void*)x11_exports->XKeysymToKeycode; } @@ -611,39 +564,27 @@ int kvm_init(int displayNo) } - sprintf_s(displayString, sizeof(displayString), ":%d", (int)displayNo); + sprintf_s(CURRENT_XDISPLAY, sizeof(CURRENT_XDISPLAY), ":%d", (int)displayNo); - if (count == 10) { return -1; } - count = 0; - eventdisplay = x11_exports->XOpenDisplay(displayString); + eventdisplay = x11_exports->XOpenDisplay(CURRENT_XDISPLAY); if (logFile) { fprintf(logFile, "XAUTHORITY is %s\n", getenv("XAUTHORITY")); fflush(logFile); } - if (logFile) { fprintf(logFile, "DisplayString is %s\n", displayString); fflush(logFile); } + if (logFile) { fprintf(logFile, "DisplayString is %s\n", CURRENT_XDISPLAY); fflush(logFile); } if (eventdisplay == NULL) { char tmpBuff[1024]; - sprintf_s(tmpBuff, sizeof(tmpBuff), "XOpenDisplay(%s) failed, using XAUTHORITY: %s", displayString, getenv("XAUTHORITY")); + sprintf_s(tmpBuff, sizeof(tmpBuff), "XOpenDisplay(%s) failed, using XAUTHORITY: %s", CURRENT_XDISPLAY, getenv("XAUTHORITY")); //fprintf(logFile, "DisplayString=%s\n", displayString); //fprintf(logFile, "XAUTHORITY is %s", getenv("XAUTHORITY")); fflush(logFile); //fprintf(logFile, "Error calling XOpenDisplay()\n"); fflush(logFile); kvm_send_error(tmpBuff); + return(-1); } - if (eventdisplay != NULL) { current_display = (unsigned short)displayNo; } - - while (eventdisplay == NULL && count++ < 100) - { - if (getNextDisplay() == -1) { return -1; } - sprintf_s(displayString, sizeof(displayString), ":%d", (int)current_display); - eventdisplay = x11_exports->XOpenDisplay(displayString); - } - - if (count == 100 && eventdisplay == NULL) { return -1; } - g_enableEvents = x11_exports->XQueryExtension(eventdisplay, "XTEST", &dummy1, &dummy2, &dummy3)? 1 : 0; if (!g_enableEvents) { printf("FATAL::::Fake motion is not supported.\n\n\n"); } - SCREEN_NUM = DefaultScreen(eventdisplay); + CURRENT_DISPLAY_ID = SCREEN_NUM = DefaultScreen(eventdisplay); SCREEN_HEIGHT = DisplayHeight(eventdisplay, SCREEN_NUM); SCREEN_WIDTH = DisplayWidth(eventdisplay, SCREEN_NUM); SCREEN_DEPTH = DefaultDepth(eventdisplay, SCREEN_NUM); @@ -674,9 +615,26 @@ int kvm_init(int displayNo) void CheckDesktopSwitch(int checkres) { - if (change_display) { - kvm_init(current_display); + if (change_display) + { + if (logFile) { fprintf(logFile, "kvm_init(%d) checkDesktopSwitch\n", CURRENT_DISPLAY_ID); fflush(logFile); } + int old_height_count = TILE_HEIGHT_COUNT; change_display = 0; + + SCREEN_NUM = CURRENT_DISPLAY_ID; + SCREEN_HEIGHT = DisplayHeight(eventdisplay, CURRENT_DISPLAY_ID); + SCREEN_WIDTH = DisplayWidth(eventdisplay, CURRENT_DISPLAY_ID); + SCREEN_DEPTH = DefaultDepth(eventdisplay, CURRENT_DISPLAY_ID); + + TILE_HEIGHT_COUNT = SCREEN_HEIGHT / TILE_HEIGHT; + TILE_WIDTH_COUNT = SCREEN_WIDTH / TILE_WIDTH; + if (SCREEN_WIDTH % TILE_WIDTH) { TILE_WIDTH_COUNT++; } + if (SCREEN_HEIGHT % TILE_HEIGHT) { TILE_HEIGHT_COUNT++; } + + kvm_send_resolution(); + kvm_send_display(); + + reset_tile_info(old_height_count); return; } } @@ -776,8 +734,8 @@ int kvm_server_inputdata(char* block, int blocklen) } case MNG_KVM_SET_DISPLAY: { - if (ntohs(((unsigned short*)(block))[2]) == current_display) { break; } // Don't do anything - current_display = ntohs(((unsigned short*)(block))[2]); + if (ntohs(((unsigned short*)(block))[2]) == CURRENT_DISPLAY_ID) { break; } // Don't do anything + CURRENT_DISPLAY_ID = ntohs(((unsigned short*)(block))[2]); change_display = 1; break; } @@ -964,7 +922,7 @@ void* kvm_server_mainloop(void* parm) unsigned int mr; char *cimage; - int x, y, height, width, r, c, count = 0; + int x, y, height, width, r, c; int sentHideCursor = 0; long long desktopsize = 0; long long tilesize = 0; @@ -976,7 +934,6 @@ void* kvm_server_mainloop(void* parm) void *buf = NULL; char displayString[256] = ""; int event_base = 0, error_base = 0, cursor_descriptor = -1; - int screen_height, screen_width, screen_depth, screen_num; ssize_t written; XShmSegmentInfo shminfo; default_JPEG_error_handler = kvm_server_jpegerror; @@ -987,6 +944,8 @@ void* kvm_server_mainloop(void* parm) fd_set writeset; XEvent XE; + unsigned short currentDisplayId; + if (logFile) { fprintf(logFile, "Checking $DISPLAY\n"); fflush(logFile); } for (char **env = environ; *env; ++env) { @@ -996,7 +955,7 @@ void* kvm_server_mainloop(void* parm) { if (i == 7 && strncmp("DISPLAY", *env, 7) == 0) { - current_display = (unsigned short)atoi(*env + i + 2); + currentDisplayId = (unsigned short)atoi(*env + i + 2); if (logFile) { fprintf(logFile, "ENV[DISPLAY] = %s\n", *env + i + 2); fflush(logFile); } break; } @@ -1004,8 +963,8 @@ void* kvm_server_mainloop(void* parm) } // Init the kvm - //fprintf(logFile, "Before kvm_init.\n"); fflush(logFile); - if (kvm_init(current_display) != 0) { return (void*)-1; } + if (logFile) { fprintf(logFile, "Before kvm_init(%d).\n", currentDisplayId); fflush(logFile); } + if (kvm_init(currentDisplayId) != 0) { return (void*)-1; } kvm_send_display_list(); //fprintf(logFile, "After kvm_init.\n"); fflush(logFile); @@ -1043,24 +1002,9 @@ void* kvm_server_mainloop(void* parm) CheckDesktopSwitch(1); //fprintf(logFile, "After CheckDesktopSwitch.\n"); fflush(logFile); - sprintf_s(displayString, sizeof(displayString), ":%d", (int)current_display); - imagedisplay = x11_exports->XOpenDisplay(displayString); + imagedisplay = x11_exports->XOpenDisplay(CURRENT_XDISPLAY); - count = 0; - - if (imagedisplay == NULL && count++ < 100) - { - change_display = 1; - if (getNextDisplay() == -1) { return (void*)-1; } - //fprintf(logFile, "Before kvm_init1.\n"); fflush(logFile); - kvm_init(current_display); - //fprintf(logFile, "After kvm_init1.\n"); fflush(logFile); - change_display = 0; - if (image != NULL) { XDestroyImage(image); image = NULL; } - continue; - } - - if (count == 100 && imagedisplay == NULL) { g_shutdown = 1; break; } + if (imagedisplay == NULL) { g_shutdown = 1; break; } FD_ZERO(&readset); FD_ZERO(&errorset); FD_ZERO(&writeset); @@ -1086,9 +1030,9 @@ void* kvm_server_mainloop(void* parm) if (cursordisplay == NULL) { - if ((cursordisplay = x11_exports->XOpenDisplay(displayString))) + if ((cursordisplay = x11_exports->XOpenDisplay(CURRENT_XDISPLAY))) { - Window rootwin = x11_exports->XRootWindow(cursordisplay, 0); + Window rootwin = x11_exports->XRootWindow(cursordisplay, CURRENT_DISPLAY_ID); if (xfixes_exports->XFixesQueryExtension(cursordisplay, &event_base, &error_base)) { xfixes_exports->XFixesSelectCursorInput(cursordisplay, rootwin, 1); // Register for Cursor Change Notifications @@ -1173,29 +1117,10 @@ void* kvm_server_mainloop(void* parm) } } - screen_num = DefaultScreen(imagedisplay); - screen_height = DisplayHeight(imagedisplay, screen_num); - screen_width = DisplayWidth(imagedisplay, screen_num); - screen_depth = DefaultDepth(imagedisplay, screen_num); - - if (screen_depth <= 15) { - //fprintf(logFile, "We do not support display depth %d < 15.\n", screen_depth); fflush(logFile); - //fprintf(stderr, "We do not support display depth <= 15."); - break; - } - - if ((SCREEN_HEIGHT != screen_height || SCREEN_WIDTH != screen_width || SCREEN_DEPTH != screen_depth || SCREEN_NUM != screen_num)) - { - kvm_init(current_display); - if (image != NULL) { XDestroyImage(image); image = NULL; } - continue; - } - - image = x11ext_exports->XShmCreateImage(imagedisplay, - DefaultVisual(imagedisplay, screen_num), // Use a correct visual. Omitted for brevity - screen_depth, - ZPixmap, NULL, &shminfo, screen_width, screen_height); + DefaultVisual(imagedisplay, SCREEN_NUM), // Use a correct visual. Omitted for brevity + SCREEN_DEPTH, + ZPixmap, NULL, &shminfo, SCREEN_WIDTH, SCREEN_HEIGHT); shminfo.shmid = shmget(IPC_PRIVATE, image->bytes_per_line * image->height, IPC_CREAT | 0777); @@ -1204,7 +1129,7 @@ void* kvm_server_mainloop(void* parm) x11ext_exports->XShmAttach(imagedisplay, &shminfo); x11ext_exports->XShmGetImage(imagedisplay, - RootWindowOfScreen(DefaultScreenOfDisplay(imagedisplay)), + RootWindowOfScreen(ScreenOfDisplay(imagedisplay, CURRENT_DISPLAY_ID)), image, 0, 0, @@ -1220,7 +1145,7 @@ void* kvm_server_mainloop(void* parm) } else { - rs = x11_exports->XQueryPointer(imagedisplay, RootWindowOfScreen(DefaultScreenOfDisplay(imagedisplay)), + rs = x11_exports->XQueryPointer(imagedisplay, RootWindowOfScreen(ScreenOfDisplay(imagedisplay, CURRENT_DISPLAY_ID)), &rr, &cr, &rx, &ry, &wx, &wy, &mr); if (rs == 1 && cursordisplay != NULL) { @@ -1237,10 +1162,10 @@ void* kvm_server_mainloop(void* parm) //if (logFile) { fprintf(logFile, "BBP: %d, pad: %d, unit: %d, BPP: %d, F: %d, XO: %d: PW: %d\n", image->bytes_per_line, image->bitmap_pad, image->bitmap_unit, image->bits_per_pixel, image->format, image->xoffset, (adjust_screen_size(SCREEN_WIDTH) - image->width) * 3); fflush(logFile); } //if (logFile) { fprintf(logFile, "[%d/ %d x %d] (%d, %d) => (%d, %d | %u, %u)\n", image->bits_per_pixel, xa.width, xa.height, screen_width, screen_height, rx, ry,w , h); fflush(logFile); } - if (xhot > rx) { mx = 0; } else if ((mx + w) > screen_width) { mx = screen_width - w; } - if (yhot > ry) { my = 0; } else if ((my + h) > screen_height) { my = screen_height - h; } + if (xhot > rx) { mx = 0; } else if ((mx + w) > SCREEN_WIDTH) { mx = SCREEN_WIDTH - w; } + if (yhot > ry) { my = 0; } else if ((my + h) > SCREEN_HEIGHT) { my = SCREEN_HEIGHT - h; } - bitblt(pixels, (int)w, (int)h, 0, 0, (int)w, (int)h, image->data, screen_width, screen_height, mx, my, 1); + bitblt(pixels, (int)w, (int)h, 0, 0, (int)w, (int)h, image->data, SCREEN_WIDTH, SCREEN_HEIGHT, mx, my, 1); if (sentHideCursor == 0) { diff --git a/microscript/ILibDuktape_Polyfills.c b/microscript/ILibDuktape_Polyfills.c index d532581..56b046d 100644 --- a/microscript/ILibDuktape_Polyfills.c +++ b/microscript/ILibDuktape_Polyfills.c @@ -2376,7 +2376,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'));"); + duk_peval_string_noresult(ctx, "addCompressedModule('monitor-info', Buffer.from('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', 'base64'), '2021-08-24T23:40:27.000-07:00');"); // service-host. Refer to modules/service-host.js duk_peval_string_noresult(ctx, "addCompressedModule('service-host', Buffer.from('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', 'base64'));"); @@ -2401,7 +2401,7 @@ void ILibDuktape_Polyfills_JS_Init(duk_context *ctx) ILibDuktape_AddCompressedModule(ctx, "service-manager", _servicemanager); free(_servicemanager); - duk_peval_string_noresult(ctx, "addCompressedModule('user-sessions', Buffer.from('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', 'base64'));"); + duk_peval_string_noresult(ctx, "addCompressedModule('user-sessions', Buffer.from('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', 'base64'), '2021-08-24T15:51:21.000-07: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 846ffb3..bf4d178 100644 --- a/modules/monitor-info.js +++ b/modules/monitor-info.js @@ -527,11 +527,73 @@ function monitorinfo() if (ret == null) { // This Linux Distro does not spawn an XServer instance in the user session, that specifies the XAUTHORITY. + if (process.platform == 'linux' && require('user-sessions').hasLoginCtl) + { + child = require('child_process').execFile('/bin/sh', ['sh']); + child.stdout.str = ''; child.stdout.on('data', function (chunk) { this.str += chunk.toString(); }); + child.stderr.str = ''; child.stderr.on('data', function (chunk) { this.str += chunk.toString(); }); + + child.stdin.write("loginctl list-sessions | tr '\\n' '`' | awk '{"); + child.stdin.write('printf "[";'); + child.stdin.write('del="";'); + child.stdin.write('n=split($0, lines, "`");'); + child.stdin.write('for(i=1;i1?",":""), tok[2], tok[1]; } printf "}"; }\'\nexit\n'); - child.waitExit(); - var ret = {}; - - try + if (process.platform == 'freebsd' || !this.hasLoginCtl) { - ret = JSON.parse(child.stdout.str.trim()); - for (var key in ret) + child.stdin.write("who | tr '\\n' '`' | awk -F'`' '" + '{ printf "{"; for(a=1;a1?",":""), tok[2], tok[1]; } printf "}"; }\'\nexit\n'); + child.waitExit(); + } + else + { + var min = this.minUid(); + + child.stdin.write("loginctl list-sessions | tr '\\n' '`' | awk '{"); + child.stdin.write('printf "[";'); + child.stdin.write('del="";'); + child.stdin.write('n=split($0, lines, "`");'); + child.stdin.write('for(i=1;i=' + min + ')'); + child.stdin.write(' {'); + child.stdin.write(' if(tok[4]=="") { continue; }'); + child.stdin.write(' printf "%s{\\"Username\\": \\"%s\\", \\"SessionId\\": \\"%s\\", \\"State\\": \\"Online\\", \\"uid\\": \\"%s\\"}", del, tok[3], tok[1], tok[2];'); + child.stdin.write(' del=",";'); + child.stdin.write(' }'); + child.stdin.write('}'); + child.stdin.write('printf "]";'); + child.stdin.write("}'\nexit\n"); + child.waitExit(); + + var info1 = JSON.parse(child.stdout.str); + var sids = []; + var i; + for (i = 0; i < info1.length; ++i) { sids.push(info1[i].SessionId); } + + child = require('child_process').execFile('/bin/sh', ['sh']); + child.stdout.str = ''; child.stdout.on('data', function (chunk) { this.str += chunk.toString(); }); + child.stderr.str = ''; child.stderr.on('data', function (chunk) { this.str += chunk.toString(); }); + child.stdin.write("loginctl show-session -p State " + sids.join(' ') + " | grep State= | tr '\\n' '`' | awk -F'`' '{"); + child.stdin.write(' for(n=1;n 0) + { + info1[i - 1].State = 'Active'; + } + ret = info1; + } + + if (ret == null) + { + try + { + ret = JSON.parse(child.stdout.str.trim()); + for (var key in ret) + { + ret[key] = { Username: ret[key], SessionId: key, State: 'Active', uid: this.getUid(ret[key]) }; + } + } + catch (e) { - ret[key] = { Username: ret[key], SessionId: key, State: 'Active', uid: this.getUid(ret[key]) }; } } - catch(e) - { - } - Object.defineProperty(ret, 'Active', { value: showActiveOnly(ret) }); if (cb) @@ -566,31 +636,79 @@ function UserSessions() var child = require('child_process').execFile('/bin/sh', ['sh']); child.stdout.str = ''; child.stdout.on('data', function (chunk) { this.str += chunk.toString(); }); child.stderr.str = ''; child.stderr.on('data', function (chunk) { this.str += chunk.toString(); }); - child.stdin.write("who | tr '\\n' '`' | awk -F'`' '{"); - child.stdin.write(" for(i=1;i=' + min + ')'); + child.stdin.write(' {'); + child.stdin.write(' if(tok[4]=="") { continue; }'); + child.stdin.write(' printf "%s{\\"uid\\": \\"%s\\", \\"sid\\": \\"%s\\"}", del, tok[2], tok[1];'); + child.stdin.write(' del=",";'); + child.stdin.write(' }'); + child.stdin.write('}'); + child.stdin.write('printf "]";'); + child.stdin.write("}'\nexit\n"); + child.waitExit(); + var info1 = JSON.parse(child.stdout.str); + var sids = []; + var i; + for (i = 0; i < info1.length; ++i) { sids.push(info1[i].sid); } + + child = require('child_process').execFile('/bin/sh', ['sh']); + child.stdout.str = ''; child.stdout.on('data', function (chunk) { this.str += chunk.toString(); }); + child.stderr.str = ''; child.stderr.on('data', function (chunk) { this.str += chunk.toString(); }); + child.stdin.write("loginctl show-session -p State " + sids.join(' ') + " | grep State= | tr '\\n' '`' | awk -F'`' '{"); + child.stdin.write(' for(n=1;n 0) + { + return (parseInt(info1[i - 1].uid)); } }