แแก แแ แแก แแแแ แ แแแแแฎแแแแ แกแขแแขแแแแแก แกแแ แแแก แจแแกแแฎแแ แฆแแ แแแแแก แแ แแแ แแแแแแก แขแแกแขแแ แแแแก แจแแกแแฎแแ RDP แแ แแขแแแแแแแ แแฃแจแแแแแกแแแแก. แแแกแจแ แฉแแแ แแแแแแฎแแแแแ rdesktop แแแแแแขแก แแ xrdp แกแแ แแแ แก.
แแแแแแงแแแแแ แ แแแแ แช แจแแชแแแแแแแก แแแแแขแแคแแชแแ แแแแก แกแแจแฃแแแแแ
แกแขแแขแแแจแ แฌแแ แแแแแแแแแแ แแฎแแแแ แแก แจแแชแแแแแแ, แ แแแแแแแช แฉแแแแแแก แกแแแแขแแ แแกแ แฉแแแแ. แแฃแแชแ, แแ แแแฅแขแแแ แแชแแ แแ, แแแแขแแ แจแแชแแแแแแ แชแแขแ แแงแ :).
แจแแแแจแแแ. แฌแแแ แกแขแแขแแ FreeRDP แแ แแแฅแขแแก แแแแแแแฌแแแแแก แจแแกแแฎแแ แจแแแแซแแแแ แแฎแแแแ
rdesktop
แแก แแแแแแขแ แซแแแแแ แแแแฃแแแ แฃแแแ - แแก แแแแฃแแแกแฎแแแแแ แแแแแแงแแแแแ ReactOS-แจแ แแ แแกแแแ แจแแแแซแแแแ แแแแแแ แแแกแแแ แแฎแแ แแก แแ แแคแแแฃแแ แฌแแแ แแแฌแแแแแ. แแฃแแชแ, แแก แกแแแแแแ แแกแแแแแแแแ: แแแกแ แแแ แแแแ แแแแแจแแแแ แจแแแแ 4 แฌแแแก 2001 แแแ แแแก - แฌแแ แแก แแ แแก แแก 17 แฌแแแกแแ.
แ แแแแ แช แฃแแแ แแฆแแแแจแแ, แแ แแแฅแขแ แซแแแแแ แแชแแ แแ. แแก แจแแแชแแแก แแแแฎแแแแแแ 30 แแแแก แฎแแแก แแแแก, แ แแช แชแแขแ แฃแชแแแฃแ แแ แแแกแ แแกแแแแก แแแแแแแแกแฌแแแแแแ. แจแแแแ แแแแกแแแแก, FreeRDP แจแแแชแแแก 320 แแแแก แฎแแแก. แแฅ แแ แแก Cloc แแ แแแ แแแแก แแแแแแแแแแ:
แแแฃแฌแแแแแแแ แแแแ
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);
}
แจแแชแแแแ แแแจแแแแ แฎแแแแแ แคแฃแแฅแชแแแจแ แแแแแแ แ: แฉแแแ แแฎแแแแแ แแแแก, แ แแแแแแช แแแแแก แแแแ แแขแแ แแก แจแแแแแ แแแแ แฃแแแแแก โ แแก แคแ แแแแแแขแ แแกแ แฃแแแแก แแแฎแกแแแ แแแแก แแแฌแแแแแแก. แแฃแแชแ, แจแแชแแแแ แแ แฌแแ แแแแแแแแก แกแแคแ แแฎแแก: แงแแแแ แแแแแงแแคแแแ แแแฎแกแแแ แแแ แแแกแฃแคแแแแแแแ แแแแ แแชแแฃแแ แกแแกแขแแแแก แแแแ แแ แแแ แแแแก แแแกแแแแก แจแแแแแ.
แจแแชแแแแแแแก แแแแฃแจแแแแแ แแ แแ แแก
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-แแก แแแแแงแแแแแ char แขแแแแก
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
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-แแก: แแ แจแแแแฎแแแแแจแ แฉแแแ แแฆแแแแฉแแแแแแ แขแแขแจแ แกแฎแแ: แชแแแแแ mod_time แงแแแแแแแแก แแฅแแแแ 0, แแแฃแฎแแแแแแ แจแแแแแแแ แแแแแแแ แแแแแกแ.
- แแ แ-แแ แแ แชแแแแแ แแ แแก 0: mod_time แแฅแแแแ 0-แแก แขแแแ (แแ แแแ แแแแ, แ แแ แกแฎแแ แชแแแแแก แแฅแแก แแ แแฃแแ แงแแคแแแ แแแแจแแแแแแแ), แ แแแแแ MIN แแแ แฉแแแก แแ แ แแแ แแแแขแแแแ แแแขแแ แแก.
- แแ แแแ แชแแแแแ แแ แแ แแก 0-แแก แขแแแ: แแแ แฉแแแ แแแแแแแแฃแ แ แแแแจแแแแแแแ.
แแแแแแแ แแแแแก แจแแชแแแแกแแก write_time && change_time แฅแชแแแ แกแฌแแ แแ แแแแแแงแฃแ แแแ:
- แแ แแ แแ แแ แแแ แชแแแแแ แแ แแ แแก 0-แแก แขแแแ: แแแ แฉแแแ แแ แแแฃแแแแแแ แแแแจแแแแแแแ.
- แแ แแแ แชแแแแแ แแ แแ แแก 0-แแก แขแแแ: แแแ แฉแแแ แแแแแแแแฃแ แ แแแแจแแแแแแแ.
แคแ แแแแแแขแ 2
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 แแแแจแแแแแแแ.
แฎแแแแก แจแแฃแแฆแฃแแแแ แแแแแ แแแ
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, ....).
แแแแแแขแ แแแแแแแ แแแแ
static void
inRepos(STREAM in, unsigned int read)
{
SERVER_DWORD add = 4 - read % 4;
if (add < 4 && add > 0)
{
....
}
}
ะัะพะฒะตัะบะฐ แแแแแแขแแ > 0 แแฅ แแ แแ แแก แกแแญแแ แ: แชแแแแแ แงแแแแแแแแก แแฅแแแแ แแฃแแแ แแแขแ, แ แแแแแ แฌแแแแแแฎแแ % 4 แแแแแ แฃแแแแก แแแงแแคแแก แแแ แฉแแแแ แแแฌแแแก, แแแแ แแ แแก แแ แแกแแแแก แแฅแแแแ 4-แแก แขแแแ.
xrdp
- xrdp - แแ แแขแแแแแแก แแแแฎแแ แชแแแแแแ. แแแแแฌแแแแแฃแแแ Apache 2.0 แแแชแแแแแแ.
- xorgxrdp - Xorg แแ แแแแแ แแแแก แแแแ แแแ xrdp-แแแ แแแแแกแแงแแแแแแแ. แแแชแแแแแ - X11 (แ แแแแ แช MIT, แแแแ แแ แแ แซแแแแแก แ แแแแแแแจแ แแแแแงแแแแแแก)
แแ แแแฅแขแแก แจแแแฃแจแแแแแ แแคแฃแซแแแแ rdesktop-แแกแ แแ FreeRDP-แแก แจแแแแแแแก. แแแแแแแแ แแแแแ, แแ แแคแแแแกแแแ แแฃแจแแแแแกแแแแก, แแฅแแแ แฃแแแ แแแแแแงแแแแแแแแ แชแแแแ VNC แกแแ แแแ แ, แแ แกแแแชแแแแฃแ แ X11 แกแแ แแแ แ RDP แแฎแแ แแแญแแ แแ - X11rdp, แแแแ แแ xorgxrdp-แแก แแแกแแแแกแแแ แแ แแแ, แแแแ แกแแญแแ แแแแ แแแฅแ แ.
แแ แกแขแแขแแแจแ แฉแแแ แแ แแแแแจแฃแฅแแแ xorgxrdp.
xrdp แแ แแแฅแขแ, แแกแแแ แ แแแแ แช แฌแแแ, แซแแแแแ แแชแแ แแ แแ แจแแแชแแแก แแแแฎแแแแแแ 80 แแแแก แฎแแแก.
แแแขแ แจแแชแแแแ
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++;
}
....
}
....
}
แแก แแแแ แแฆแแแฃแแแ librfxcodec แแแแแแแแแแแแแ, แ แแแแแแช แแฎแแ แชแแแแแแก jpeg2000 แแแแแแก RemoteFX-แแกแแแแก. แแฅ, แ แแแแ แช แฉแแแก, แแ แแคแแแฃแแ แแแแแชแแแแ แแ แฎแแแ แแแ แแ - "แแฃแ แฏแ" แคแแ แแก แแแชแแแแ, "แฌแแแแแ" แแ แแก แฉแแฌแแ แแแ. แแก แจแแชแแแแ, แกแแแแ แแฃแแแ, แแแฉแแแ แแแแแ -แแแกแขแแก แจแแแแแแ.
แแแแแ แแ แแแแแแ แฌแแ แแแแจแแ แแกแแแแก แคแฃแแฅแชแแแจแ rfx_encode_format_argb, แ แแแแแแช แแแแแแแแขแแ แแ แแกแแแ แแแแแฎแ แ:
while (x < 64)
{
*la_buf++ = a;
*lr_buf++ = r;
*lg_buf++ = g;
*lb_buf++ = r;
x++;
}
แแแกแแแแก แแแแแแ แแชแแ
// 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 แคแแแแจแ, แแแแขแแ แแ แแ แแก แกแแแฆแแ แแแ. แแกแ แ แแ, แแก แแฎแแแแ แจแแชแแแแแ, แ แแแแแแช แแแแแแแ แแแแแกแฌแแ แแแแ.
แแ แแกแฌแแ แ แจแแแแ แแแ
// 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. แจแแแแฌแแแแ แแฅ แแ แแ แแก แกแแญแแ แ, แ แแแแแ แฉแแแ แแแแแฎแฃแแแแ แฎแแแแแฃแฌแแ แแ แชแแแแแก แแ แจแแแแแก แแแแแญแแแ แฃแคแ แ แแแ แชแแแแแก, แแแแขแแ แชแแแแแ แแแ แแแแฆแแแก แฃแแ แงแแคแแ แแแแจแแแแแแแแก.
แแ แแกแแญแแ แ แจแแแแฌแแแแแแ
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-แก แกแแชแแแแ แแแ แกแแ
แแฃ แแกแฃแ แ แแแฃแแแแ แแ แแก แกแขแแขแแ แแแแแแกแฃแ แแแแแแ แแฃแแแขแแ แแแก, แแแฎแแแ, แแแแแแงแแแแ แแแ แแแแแแก แแแฃแแ: แกแแ แแแ แแแ แแแ.
แฌแงแแ แ: www.habr.com