PVS-Studio അനലൈസർ ഉപയോഗിച്ച് rdesktop, xrdp എന്നിവ പരിശോധിക്കുന്നു

RDP പ്രോട്ടോക്കോളുമായി പ്രവർത്തിക്കുന്നതിനുള്ള ഓപ്പൺ സോഴ്‌സ് പ്രോഗ്രാമുകൾ പരിശോധിക്കുന്നതിനെക്കുറിച്ചുള്ള ലേഖനങ്ങളുടെ പരമ്പരയിലെ രണ്ടാമത്തെ അവലോകനമാണിത്. അതിൽ നമ്മൾ rdesktop ക്ലയന്റും xrdp സെർവറും നോക്കും.

പിശകുകൾ തിരിച്ചറിയുന്നതിനുള്ള ഒരു ഉപകരണമായി ഉപയോഗിക്കുന്നു പിവിഎസ്-സ്റ്റുഡിയോ. ഇത് C, C++, C#, Java എന്നീ ഭാഷകൾക്കായുള്ള ഒരു സ്റ്റാറ്റിക് കോഡ് അനലൈസറാണ്, ഇത് Windows, Linux, macOS പ്ലാറ്റ്‌ഫോമുകളിൽ ലഭ്യമാണ്.

എനിക്ക് രസകരമായി തോന്നിയ തെറ്റുകൾ മാത്രമാണ് ലേഖനം അവതരിപ്പിക്കുന്നത്. എന്നിരുന്നാലും, പ്രോജക്റ്റുകൾ ചെറുതാണ്, അതിനാൽ കുറച്ച് തെറ്റുകൾ ഉണ്ടായിരുന്നു :).

അഭിപായപ്പെടുക. FreeRDP പ്രോജക്റ്റ് പരിശോധനയെക്കുറിച്ചുള്ള ഒരു മുൻ ലേഖനം കാണാം ഇവിടെ.

rdesktop

rdesktop - UNIX-അധിഷ്ഠിത സിസ്റ്റങ്ങൾക്കായി ഒരു RDP ക്ലയന്റ് സൗജന്യമായി നടപ്പിലാക്കുന്നു. നിങ്ങൾ Cygwin ന് കീഴിൽ പ്രോജക്റ്റ് നിർമ്മിക്കുകയാണെങ്കിൽ വിൻഡോസിന് കീഴിലും ഇത് ഉപയോഗിക്കാം. GPLv3 പ്രകാരം ലൈസൻസ്.

ഈ ക്ലയന്റ് വളരെ ജനപ്രിയമാണ് - ഇത് ReactOS-ൽ സ്ഥിരസ്ഥിതിയായി ഉപയോഗിക്കുന്നു, കൂടാതെ നിങ്ങൾക്ക് അതിനായി മൂന്നാം-കക്ഷി ഗ്രാഫിക്കൽ ഫ്രണ്ട്-എൻഡുകളും കണ്ടെത്താനാകും. എന്നിരുന്നാലും, അദ്ദേഹത്തിന് പ്രായമുണ്ട്: അദ്ദേഹത്തിന്റെ ആദ്യ റിലീസ് 4 ഏപ്രിൽ 2001 ന് നടന്നു - എഴുതുമ്പോൾ, അദ്ദേഹത്തിന് 17 വയസ്സായിരുന്നു.

ഞാൻ നേരത്തെ സൂചിപ്പിച്ചതുപോലെ, പദ്ധതി വളരെ ചെറുതാണ്. അതിൽ ഏകദേശം 30 ആയിരം കോഡ് ലൈനുകൾ അടങ്ങിയിരിക്കുന്നു, ഇത് അതിന്റെ പ്രായം കണക്കിലെടുക്കുമ്പോൾ അൽപ്പം വിചിത്രമാണ്. താരതമ്യത്തിനായി, FreeRDP-യിൽ 320 ആയിരം ലൈനുകൾ അടങ്ങിയിരിക്കുന്നു. ക്ലോക്ക് പ്രോഗ്രാമിന്റെ ഔട്ട്പുട്ട് ഇതാ:

എത്തിച്ചേരാനാകാത്ത കോഡ്

V779 ലഭ്യമല്ലാത്ത കോഡ് കണ്ടെത്തി. ഒരു പിശക് ഉണ്ടാകാൻ സാധ്യതയുണ്ട്. rdesktop.c 1502

int
main(int argc, char *argv[])
{
  ....
  return handle_disconnect_reason(deactivated, ext_disc_reason);

  if (g_redirect_username)
    xfree(g_redirect_username);

  xfree(g_username);
}

പ്രവർത്തനത്തിൽ പിശക് ഞങ്ങളെ ഉടൻ നേരിടുന്നു പ്രധാന: ഓപ്പറേറ്ററിന് ശേഷം കോഡ് വരുന്നത് ഞങ്ങൾ കാണുന്നു മടക്കം - ഈ ശകലം മെമ്മറി ക്ലീനിംഗ് നടത്തുന്നു. എന്നിരുന്നാലും, പിശക് ഒരു ഭീഷണി ഉയർത്തുന്നില്ല: പ്രോഗ്രാം പുറത്തുകടന്നതിന് ശേഷം അനുവദിച്ച എല്ലാ മെമ്മറിയും ഓപ്പറേറ്റിംഗ് സിസ്റ്റം മായ്‌ക്കും.

പിശക് കൈകാര്യം ചെയ്യൽ ഇല്ല

V557 അറേ അണ്ടർറൺ സാധ്യമാണ്. 'n' സൂചികയുടെ മൂല്യം -1 ൽ എത്താം. rdesktop.c 1872

RD_BOOL
subprocess(char *const argv[], str_handle_lines_t linehandler, void *data)
{
  int n = 1;
  char output[256];
  ....
  while (n > 0)
  {
    n = read(fd[0], output, 255);
    output[n] = ' '; // <=
    str_handle_lines(output, &rest, linehandler, data);
  }
  ....
}

ഈ കേസിലെ കോഡ് സ്‌നിപ്പെറ്റ് ഫയൽ അവസാനിക്കുന്നത് വരെ ഫയലിൽ നിന്ന് ഒരു ബഫറിലേക്ക് റീഡ് ചെയ്യുന്നു. എന്നിരുന്നാലും, ഇവിടെ പിശക് കൈകാര്യം ചെയ്യുന്നില്ല: എന്തെങ്കിലും തെറ്റ് സംഭവിച്ചാൽ, പിന്നെ വായിക്കുക -1 തിരികെ നൽകും, തുടർന്ന് അറേ മറികടക്കും ഔട്ട്പുട്ട്.

ചാർ തരത്തിൽ EOF ഉപയോഗിക്കുന്നു

V739 EOF-നെ 'char' തരം മൂല്യവുമായി താരതമ്യം ചെയ്യാൻ പാടില്ല. '(c = fgetc(fp))' എന്നത് 'int' തരത്തിലായിരിക്കണം. ctrl.c 500

int
ctrl_send_command(const char *cmd, const char *arg)
{
  char result[CTRL_RESULT_SIZE], c, *escaped;
  ....
  while ((c = fgetc(fp)) != EOF && index < CTRL_RESULT_SIZE && c != 'n')
  {
    result[index] = c;
    index++;
  }
  ....
}

ഫയലിന്റെ അവസാനത്തിൽ എത്തുന്നതിന്റെ തെറ്റായ കൈകാര്യം ചെയ്യൽ ഇവിടെ കാണാം: if fgetc 0xFF കോഡ് ഉള്ള ഒരു പ്രതീകം നൽകുന്നു, അത് ഫയലിന്റെ അവസാനമായി വ്യാഖ്യാനിക്കപ്പെടും (EOF).

EOF ഇത് ഒരു സ്ഥിരാങ്കമാണ്, സാധാരണയായി -1 ആയി നിർവചിക്കപ്പെടുന്നു. ഉദാഹരണത്തിന്, CP1251 എൻകോഡിംഗിൽ, റഷ്യൻ അക്ഷരമാലയുടെ അവസാന അക്ഷരത്തിന് 0xFF എന്ന കോഡ് ഉണ്ട്, ഇത് നമ്മൾ ഒരു വേരിയബിളിനെക്കുറിച്ചാണ് സംസാരിക്കുന്നതെങ്കിൽ -1 എന്ന സംഖ്യയുമായി യോജിക്കുന്നു. പ്രതീകം. ചിഹ്നം 0xFF പോലെയാണെന്ന് ഇത് മാറുന്നു EOF (-1) ഫയലിന്റെ അവസാനമായി വ്യാഖ്യാനിക്കപ്പെടുന്നു. അത്തരം പിശകുകൾ ഒഴിവാക്കാൻ, പ്രവർത്തനത്തിന്റെ ഫലം fgetc പോലുള്ള ഒരു വേരിയബിളിൽ സൂക്ഷിക്കണം int.

അക്ഷരത്തെറ്റുകൾ

ശകലം 1

V547 'write_time' എന്ന പ്രയോഗം എപ്പോഴും തെറ്റാണ്. disk.c 805

RD_NTSTATUS
disk_set_information(....)
{
  time_t write_time, change_time, access_time, mod_time;
  ....
  if (write_time || change_time)
    mod_time = MIN(write_time, change_time);
  else
    mod_time = write_time ? write_time : change_time; // <=
  ....
}

ഒരുപക്ഷേ ഈ കോഡിന്റെ രചയിതാവ് തെറ്റിദ്ധരിച്ചിരിക്കാം || и && അവസ്ഥയിലാണ്. മൂല്യങ്ങൾക്കുള്ള സാധ്യമായ ഓപ്ഷനുകൾ നമുക്ക് പരിഗണിക്കാം എഴുതുക_സമയം и മാറ്റം_സമയം:

• രണ്ട് വേരിയബിളുകളും 0 ന് തുല്യമാണ്: ഈ സാഹചര്യത്തിൽ നമ്മൾ ഒരു ശാഖയിൽ അവസാനിക്കും മറ്റാരെങ്കിലും: വേരിയബിൾ മോഡ്_ടൈം തുടർന്നുള്ള അവസ്ഥ പരിഗണിക്കാതെ എപ്പോഴും 0 ആയിരിക്കും.
• വേരിയബിളുകളിലൊന്ന് 0 ആണ്: മോഡ്_ടൈം 0 ന് തുല്യമായിരിക്കും (മറ്റൊരു വേരിയബിളിന് നെഗറ്റീവ് അല്ലാത്ത മൂല്യമുണ്ടെങ്കിൽ), കാരണം MIN രണ്ട് ഓപ്ഷനുകളിൽ ചെറിയത് തിരഞ്ഞെടുക്കും.
• രണ്ട് വേരിയബിളുകളും 0 ന് തുല്യമല്ല: ഏറ്റവും കുറഞ്ഞ മൂല്യം തിരഞ്ഞെടുക്കുക.

വ്യവസ്ഥ മാറ്റിസ്ഥാപിക്കുമ്പോൾ എഴുതുക_സമയം && സമയം_മാറ്റുക പെരുമാറ്റം ശരിയായി കാണപ്പെടും:

• ഒന്നോ രണ്ടോ വേരിയബിളുകൾ 0 ന് തുല്യമല്ല: പൂജ്യമല്ലാത്ത മൂല്യം തിരഞ്ഞെടുക്കുക.
• രണ്ട് വേരിയബിളുകളും 0 ന് തുല്യമല്ല: ഏറ്റവും കുറഞ്ഞ മൂല്യം തിരഞ്ഞെടുക്കുക.

ശകലം 2

V547 ആവിഷ്കാരം എപ്പോഴും സത്യമാണ്. ഒരുപക്ഷേ ഇവിടെ '&&' ഓപ്പറേറ്റർ ഉപയോഗിച്ചിരിക്കണം. disk.c 1419

static RD_NTSTATUS
disk_device_control(RD_NTHANDLE handle, uint32 request, STREAM in,
      STREAM out)
{
  ....
  if (((request >> 16) != 20) || ((request >> 16) != 9))
    return RD_STATUS_INVALID_PARAMETER;
  ....
}

പ്രത്യക്ഷത്തിൽ ഓപ്പറേറ്റർമാർ ഇവിടെയും ഇടകലർന്നിരിക്കുന്നു || и &&, അല്ലെങ്കിൽ == и !=: ഒരു വേരിയബിളിന് ഒരേ സമയം 20, 9 എന്നീ മൂല്യങ്ങൾ ഉണ്ടാകരുത്.

അൺലിമിറ്റഡ് ലൈൻ പകർത്തൽ

V512 'sprintf' ഫംഗ്‌ഷന്റെ ഒരു കോൾ ബഫർ 'ഫുൾപാത്ത്' ഓവർഫ്ലോയിലേക്ക് നയിക്കും. disk.c 1257

RD_NTSTATUS
disk_query_directory(....)
{
  ....
  char *dirname, fullpath[PATH_MAX];
  ....
  /* Get information for directory entry */
  sprintf(fullpath, "%s/%s", dirname, pdirent->d_name);
  ....
}

നിങ്ങൾ ഫംഗ്ഷൻ പൂർണ്ണമായി നോക്കുമ്പോൾ, ഈ കോഡ് പ്രശ്നങ്ങൾ ഉണ്ടാക്കുന്നില്ലെന്ന് വ്യക്തമാകും. എന്നിരുന്നാലും, അവ ഭാവിയിൽ ഉണ്ടായേക്കാം: ഒരു അശ്രദ്ധമായ മാറ്റം, ഞങ്ങൾക്ക് ഒരു ബഫർ ഓവർഫ്ലോ ലഭിക്കും - സ്പ്രിന്റ്ഫ് ഒന്നിലും പരിമിതപ്പെടുത്തിയിട്ടില്ല, അതിനാൽ പാതകൾ സംയോജിപ്പിക്കുമ്പോൾ നമുക്ക് അറേയുടെ അതിരുകൾക്കപ്പുറത്തേക്ക് പോകാം. ഈ കോളിൽ ശ്രദ്ധിക്കാൻ ശുപാർശ ചെയ്യുന്നു snprintf(ഫുൾപാത്ത്, PATH_MAX, ....).

അനാവശ്യമായ അവസ്ഥ

V560 സോപാധിക പദപ്രയോഗത്തിന്റെ ഒരു ഭാഗം എല്ലായ്പ്പോഴും ശരിയാണ്: ചേർക്കുക > 0. scard.c 507

static void
inRepos(STREAM in, unsigned int read)
{
  SERVER_DWORD add = 4 - read % 4;
  if (add < 4 && add > 0)
  {
    ....
  }
}

പരിശോധന ചേർക്കുക > 0 ഇവിടെ ആവശ്യമില്ല: വേരിയബിൾ എല്ലായ്പ്പോഴും പൂജ്യത്തേക്കാൾ വലുതായിരിക്കും, കാരണം % 4 വായിക്കുക ഡിവിഷന്റെ ശേഷിക്കുന്ന ഭാഗം തിരികെ നൽകും, പക്ഷേ അത് ഒരിക്കലും 4 ന് തുല്യമാകില്ല.

xrdp

xrdp - ഓപ്പൺ സോഴ്സ് കോഡുള്ള ഒരു RDP സെർവർ നടപ്പിലാക്കൽ. പ്രോജക്റ്റ് 2 ഭാഗങ്ങളായി തിരിച്ചിരിക്കുന്നു:

• xrdp - പ്രോട്ടോക്കോൾ നടപ്പിലാക്കൽ. അപ്പാച്ചെ 2.0 ലൈസൻസിന് കീഴിൽ വിതരണം ചെയ്തു.
• xorgxrdp - xrdp ഉപയോഗിച്ചുള്ള Xorg ഡ്രൈവറുകളുടെ ഒരു കൂട്ടം. ലൈസൻസ് - X11 (എംഐടി പോലെ, എന്നാൽ പരസ്യത്തിൽ ഉപയോഗിക്കുന്നത് നിരോധിക്കുന്നു)

rdesktop, FreeRDP എന്നിവയുടെ ഫലങ്ങളെ അടിസ്ഥാനമാക്കിയാണ് പദ്ധതിയുടെ വികസനം. തുടക്കത്തിൽ, ഗ്രാഫിക്സുമായി പ്രവർത്തിക്കാൻ, നിങ്ങൾ ഒരു പ്രത്യേക VNC സെർവർ അല്ലെങ്കിൽ RDP പിന്തുണയുള്ള ഒരു പ്രത്യേക X11 സെർവർ ഉപയോഗിക്കേണ്ടതുണ്ട് - X11rdp, എന്നാൽ xorgxrdp യുടെ വരവോടെ അവയുടെ ആവശ്യം അപ്രത്യക്ഷമായി.

ഈ ലേഖനത്തിൽ ഞങ്ങൾ xorgxrdp കവർ ചെയ്യില്ല.

xrdp പ്രോജക്റ്റ്, മുമ്പത്തേത് പോലെ, വളരെ ചെറുതാണ്, അതിൽ ഏകദേശം 80 ആയിരം ലൈനുകൾ അടങ്ങിയിരിക്കുന്നു.

കൂടുതൽ അക്ഷരത്തെറ്റുകൾ

V525 കോഡിൽ സമാന ബ്ലോക്കുകളുടെ ശേഖരം അടങ്ങിയിരിക്കുന്നു. 87, 88, 89 വരികളിലെ 'r', 'g', 'r' ഇനങ്ങൾ പരിശോധിക്കുക. rfxencode_rgb_to_yuv.c 87

static int
rfx_encode_format_rgb(const char *rgb_data, int width, int height,
                      int stride_bytes, int pixel_format,
                      uint8 *r_buf, uint8 *g_buf, uint8 *b_buf)
{
  ....
  switch (pixel_format)
  {
    case RFX_FORMAT_BGRA:
      ....
      while (x < 64)
      {
          *lr_buf++ = r;
          *lg_buf++ = g;
          *lb_buf++ = r; // <=
          x++;
      }
      ....
  }
  ....
}

RemoteFX-നുള്ള jpeg2000 കോഡെക് നടപ്പിലാക്കുന്ന librfxcodec ലൈബ്രറിയിൽ നിന്നാണ് ഈ കോഡ് എടുത്തത്. ഇവിടെ, പ്രത്യക്ഷത്തിൽ, ഗ്രാഫിക് ഡാറ്റ ചാനലുകൾ ഇടകലർന്നിരിക്കുന്നു - "നീല" നിറത്തിന് പകരം "ചുവപ്പ്" രേഖപ്പെടുത്തുന്നു. കോപ്പി-പേസ്റ്റിന്റെ ഫലമായി ഈ പിശക് ദൃശ്യമാകാൻ സാധ്യതയുണ്ട്.

സമാനമായ ഒരു ഫംഗ്‌ഷനിലും ഇതേ പ്രശ്‌നം സംഭവിച്ചു rfx_encode_format_argb, അനലൈസർ ഞങ്ങളോട് പറഞ്ഞു:

V525 കോഡിൽ സമാന ബ്ലോക്കുകളുടെ ശേഖരം അടങ്ങിയിരിക്കുന്നു. 260, 261, 262, 263 വരികളിലെ 'a', 'r', 'g', 'r' ഇനങ്ങൾ പരിശോധിക്കുക. rfxencode_rgb_to_yuv.c 260

while (x < 64)
{
    *la_buf++ = a;
    *lr_buf++ = r;
    *lg_buf++ = g;
    *lb_buf++ = r;
    x++;
}

അറേ പ്രഖ്യാപനം

V557 അറേ ഓവർറൺ സാധ്യമാണ്. 'i — 8' സൂചികയുടെ മൂല്യം 129 ൽ എത്തിയേക്കാം. genkeymap.c 142

// evdev-map.c
int xfree86_to_evdev[137-8+1] = {
  ....
};

// genkeymap.c
extern int xfree86_to_evdev[137-8];

int main(int argc, char **argv)
{
  ....
  for (i = 8; i <= 137; i++) /* Keycodes */
  {
    if (is_evdev)
        e.keycode = xfree86_to_evdev[i-8];
    ....
  }
  ....
}

ഈ രണ്ട് ഫയലുകളിലെ അറേയുടെ പ്രഖ്യാപനവും നിർവചനവും പൊരുത്തപ്പെടുന്നില്ല - വലുപ്പം 1 കൊണ്ട് വ്യത്യാസപ്പെട്ടിരിക്കുന്നു. എന്നിരുന്നാലും, പിശകുകളൊന്നും സംഭവിക്കുന്നില്ല - ശരിയായ വലുപ്പം evdev-map.c ഫയലിൽ വ്യക്തമാക്കിയിട്ടുണ്ട്, അതിനാൽ അതിരുകൾക്ക് പുറത്ത് ഒന്നുമില്ല. അതിനാൽ ഇത് എളുപ്പത്തിൽ പരിഹരിക്കാവുന്ന ഒരു ബഗ് മാത്രമാണ്.

തെറ്റായ താരതമ്യം

V560 സോപാധിക പദപ്രയോഗത്തിന്റെ ഒരു ഭാഗം എല്ലായ്പ്പോഴും തെറ്റാണ്: (cap_len <0). xrdp_caps.c 616

// common/parse.h
#if defined(B_ENDIAN) || defined(NEED_ALIGN)
#define in_uint16_le(s, v) do 
....
#else
#define in_uint16_le(s, v) do 
{ 
    (v) = *((unsigned short*)((s)->p)); 
    (s)->p += 2; 
} while (0)
#endif

int
xrdp_caps_process_confirm_active(struct xrdp_rdp *self, struct stream *s)
{
  int cap_len;
  ....
  in_uint16_le(s, cap_len);
  ....
  if ((cap_len < 0) || (cap_len > 1024 * 1024))
  {
    ....
  }
  ....
}

ഫംഗ്ഷൻ ഒരു തരം വേരിയബിൾ വായിക്കുന്നു ഒപ്പിടാത്ത ഷോർട്ട് ഒരു വേരിയബിളിലേക്ക് int. ഇവിടെ പരിശോധന ആവശ്യമില്ല, കാരണം ഞങ്ങൾ ഒപ്പിടാത്ത വേരിയബിൾ വായിക്കുകയും ഫലം ഒരു വലിയ വേരിയബിളിലേക്ക് നൽകുകയും ചെയ്യുന്നു, അതിനാൽ വേരിയബിളിന് നെഗറ്റീവ് മൂല്യം എടുക്കാൻ കഴിയില്ല.

അനാവശ്യ പരിശോധനകൾ

V560 സോപാധിക പദപ്രയോഗത്തിന്റെ ഒരു ഭാഗം എല്ലായ്പ്പോഴും ശരിയാണ്: (bpp != 16). libxrdp.c 704

int EXPORT_CC
libxrdp_send_pointer(struct xrdp_session *session, int cache_idx,
                     char *data, char *mask, int x, int y, int bpp)
{
  ....
  if ((bpp == 15) && (bpp != 16) && (bpp != 24) && (bpp != 32))
  {
      g_writeln("libxrdp_send_pointer: error");
      return 1;
  }
  ....
}

തുടക്കത്തിൽ തന്നെ ഒരു താരതമ്യം ഉള്ളതിനാൽ അസമത്വ പരിശോധനകൾ ഇവിടെ അർത്ഥമാക്കുന്നില്ല. ഇതൊരു അക്ഷരപ്പിശകായിരിക്കാം, ഡെവലപ്പർ ഓപ്പറേറ്ററെ ഉപയോഗിക്കാൻ ആഗ്രഹിച്ചിരിക്കാം || അസാധുവായ ആർഗ്യുമെന്റുകൾ ഫിൽട്ടർ ചെയ്യാൻ.

തീരുമാനം

ഓഡിറ്റ് സമയത്ത്, ഗുരുതരമായ പിഴവുകളൊന്നും കണ്ടെത്തിയില്ല, പക്ഷേ നിരവധി പോരായ്മകൾ കണ്ടെത്തി. എന്നിരുന്നാലും, ഈ ഡിസൈനുകൾ വ്യാപ്തിയിൽ ചെറുതാണെങ്കിലും പല സിസ്റ്റങ്ങളിലും ഉപയോഗിക്കുന്നു. ഒരു ചെറിയ പ്രോജക്റ്റിന് ധാരാളം പിശകുകൾ ഉണ്ടാകണമെന്നില്ല, അതിനാൽ ചെറിയ പ്രോജക്റ്റുകളിൽ മാത്രം അനലൈസറിന്റെ പ്രകടനം നിങ്ങൾ വിലയിരുത്തരുത്. ലേഖനത്തിൽ നിങ്ങൾക്ക് ഇതിനെക്കുറിച്ച് കൂടുതൽ വായിക്കാം "അക്കങ്ങളാൽ സ്ഥിരീകരിച്ച വികാരങ്ങൾ".

നിങ്ങൾക്ക് ഞങ്ങളിൽ നിന്ന് PVS-Studio-യുടെ ട്രയൽ പതിപ്പ് ഡൗൺലോഡ് ചെയ്യാം സൈറ്റ്.

ഇംഗ്ലീഷ് സംസാരിക്കുന്ന പ്രേക്ഷകരുമായി ഈ ലേഖനം പങ്കിടാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, വിവർത്തന ലിങ്ക് ഉപയോഗിക്കുക: സെർജി ലാറിൻ. PVS-Studio ഉപയോഗിച്ച് rdesktop, xrdp എന്നിവ പരിശോധിക്കുന്നു

അവലംബം: www.habr.com