uLab
/
xrdp-proprietary
mirror of https://mirror.git.trinitydesktop.org/gitea/uLab/xrdp-proprietary
0
0
Fork 0
Code Issues Releases Wiki Activity

added a bunch of error checks

Browse Source
ulab-original
jsorg71 20 years ago
parent d2da72f5c9
commit cf6e2abd41
13 changed files with 440 additions and 426 deletions
Show Stats Download Patch File Download Diff File

48
common/os_calls.c
Unescape View File

@ -38,6 +38,7 @@
#include <dlfcn.h> #include <dlfcn.h>
#include <arpa/inet.h> #include <arpa/inet.h>
#include <netdb.h> #include <netdb.h>
#include <signal.h>
#endif #endif
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@ -68,6 +69,10 @@ static int g_memid = 0;
static struct xrdp_list* g_memlist = 0; static struct xrdp_list* g_memlist = 0;
#endif #endif
/* forward declarations */
void g_printf(char* format, ...);
void pipe_sig(int sig_num);
/*****************************************************************************/ /*****************************************************************************/
int g_init_system(void) int g_init_system(void)
{ {
@ -76,13 +81,15 @@ int g_init_system(void)
WSAStartup(2, &w); WSAStartup(2, &w);
InitializeCriticalSection(&g_term_mutex); InitializeCriticalSection(&g_term_mutex);
#else
signal(SIGPIPE, pipe_sig);
#endif #endif
#ifdef MEMLEAK #ifdef MEMLEAK
g_memlist = xrdp_list_create(); g_memlist = xrdp_list_create();
printf("some info\n\r"); g_printf("some info\n\r");
printf("sizeof xrdp_bitmap is %d\n\r", sizeof(struct xrdp_bitmap)); g_printf("sizeof xrdp_bitmap is %d\n\r", sizeof(struct xrdp_bitmap));
printf("sizeof xrdp_wm is %d\n\r", sizeof(struct xrdp_wm)); g_printf("sizeof xrdp_wm is %d\n\r", sizeof(struct xrdp_wm));
printf("sizeof stream is %d\n\r", sizeof(struct stream)); g_printf("sizeof stream is %d\n\r", sizeof(struct stream));
#endif #endif
return 0; return 0;
} }
@ -225,7 +232,7 @@ void g_hexdump(char* p, int len)
offset = 0; offset = 0;
while (offset < len) while (offset < len)
{ {
printf("%04x ", offset); g_printf("%04x ", offset);
thisline = len - offset; thisline = len - offset;
if (thisline > 16) if (thisline > 16)
{ {
@ -233,17 +240,17 @@ void g_hexdump(char* p, int len)
} }
for (i = 0; i < thisline; i++) for (i = 0; i < thisline; i++)
{ {
printf("%02x ", line[i]); g_printf("%02x ", line[i]);
} }
for (; i < 16; i++) for (; i < 16; i++)
{ {
printf(" "); g_printf(" ");
} }
for (i = 0; i < thisline; i++) for (i = 0; i < thisline; i++)
{ {
printf("%c", (line[i] >= 0x20 && line[i] < 0x7f) ? line[i] : '.'); g_printf("%c", (line[i] >= 0x20 && line[i] < 0x7f) ? line[i] : '.');
} }
printf("\n\r"); g_printf("\n\r");
offset += thisline; offset += thisline;
line += thisline; line += thisline;
} }
@ -509,8 +516,14 @@ int g_tcp_select(int sck1, int sck2)
time.tv_sec = 0; time.tv_sec = 0;
time.tv_usec = 0; time.tv_usec = 0;
FD_ZERO(&rfds); FD_ZERO(&rfds);
FD_SET(((unsigned int)sck1), &rfds); if (sck1 > 0)
FD_SET(((unsigned int)sck2), &rfds); {
FD_SET(((unsigned int)sck1), &rfds);
}
if (sck2 > 0)
{
FD_SET(((unsigned int)sck2), &rfds);
}
max = sck1; max = sck1;
if (sck2 > max) if (sck2 > max)
{ {
@ -934,3 +947,16 @@ int g_system(char* aexec)
{ {
return system(aexec); return system(aexec);
} }
/*****************************************************************************/
void g_signal(int sig_num, void (*func)(int))
{
signal(sig_num, func);
}
/*****************************************************************************/
void pipe_sig(int sig_num)
{
/* do nothing */
g_printf("got SIGPIPE(%d)\n\r", sig_num);
}

1
common/os_calls.h
Unescape View File

@ -86,3 +86,4 @@ int g_load_library(char* in);
int g_free_library(int lib); int g_free_library(int lib);
void* g_get_proc_address(int lib, char* name); void* g_get_proc_address(int lib, char* name);
int g_system(char* aexec); int g_system(char* aexec);
void g_signal(int sig_num, void (*func)(int));

715
vnc/vnc.c
Unescape View File

@ -22,12 +22,94 @@
#include "vnc.h" #include "vnc.h"
/******************************************************************************/
/* returns error */
int lib_recv(struct vnc* v, char* data, int len)
{
int rcvd;
if (v->sck_closed)
{
return 1;
}
while (len > 0)
{
rcvd = g_tcp_recv(v->sck, data, len, 0);
if (rcvd == -1)
{
if (g_tcp_last_error_would_block(v->sck))
{
g_sleep(1);
}
else
{
return 1;
}
}
else if (rcvd == 0)
{
v->sck_closed = 1;
return 1;
}
else
{
data += rcvd;
len -= rcvd;
}
}
return 0;
}
/*****************************************************************************/
/* returns error */
int lib_send(struct vnc* v, char* data, int len)
{
int sent;
if (v->sck_closed)
{
return 1;
}
while (len > 0)
{
sent = g_tcp_send(v->sck, data, len, 0);
if (sent == -1)
{
if (g_tcp_last_error_would_block(v->sck))
{
g_sleep(1);
}
else
{
return 1;
}
}
else if (sent == 0)
{
v->sck_closed = 1;
return 1;
}
else
{
data += sent;
len -= sent;
}
}
return 0;
}
/******************************************************************************/ /******************************************************************************/
int lib_mod_event(struct vnc* v, int msg, int param1, int param2) int lib_mod_event(struct vnc* v, int msg, int param1, int param2)
{ {
struct stream* s; struct stream* s;
int key; int key;
int error;
int x;
int y;
int cx;
int cy;
error = 0;
make_stream(s); make_stream(s);
if (msg >= 15 && msg <= 16) /* key events */ if (msg >= 15 && msg <= 16) /* key events */
{ {
@ -81,13 +163,7 @@ int lib_mod_event(struct vnc* v, int msg, int param1, int param2)
out_uint8(s, msg == 15); /* down flag */ out_uint8(s, msg == 15); /* down flag */
out_uint8s(s, 2); out_uint8s(s, 2);
out_uint32_be(s, key); out_uint32_be(s, key);
if (g_tcp_force_send(v->sck, s->data, 8) != 0) error = lib_send(v, s->data, 8);
{
g_tcp_close(v->sck);
v->sck = 0;
free_stream(s);
return 1;
}
} }
} }
else if (msg >= 100 && msg <= 110) /* mouse events */ else if (msg >= 100 && msg <= 110) /* mouse events */
@ -111,16 +187,26 @@ int lib_mod_event(struct vnc* v, int msg, int param1, int param2)
out_uint8(s, v->mod_mouse_state); out_uint8(s, v->mod_mouse_state);
out_uint16_be(s, param1); out_uint16_be(s, param1);
out_uint16_be(s, param2); out_uint16_be(s, param2);
if (g_tcp_force_send(v->sck, s->data, 6) != 0) error = lib_send(v, s->data, 6);
{ }
g_tcp_close(v->sck); else if (msg == 200) /* invalidate */
v->sck = 0; {
free_stream(s); /* FrambufferUpdateRequest */
return 1; init_stream(s, 8192);
} out_uint8(s, 3);
out_uint8(s, 0);
x = (param1 >> 16) & 0xffff;
out_uint16_be(s, x);
y = param1 & 0xffff;
out_uint16_be(s, y);
cx = (param2 >> 16) & 0xffff;
out_uint16_be(s, cx);
cy = param2 & 0xffff;
out_uint16_be(s, cy);
error = lib_send(v, s->data, 10);
} }
free_stream(s); free_stream(s);
return 0; return error;
} }
//****************************************************************************** //******************************************************************************
@ -130,13 +216,21 @@ int get_pixel_safe(char* data, int x, int y, int width, int height, int bpp)
int shift; int shift;
if (x < 0) if (x < 0)
{
return 0; return 0;
}
if (y < 0) if (y < 0)
{
return 0; return 0;
}
if (x >= width) if (x >= width)
{
return 0; return 0;
}
if (y >= height) if (y >= height)
{
return 0; return 0;
}
if (bpp == 1) if (bpp == 1)
{ {
width = (width + 7) / 8; width = (width + 7) / 8;
@ -150,9 +244,13 @@ int get_pixel_safe(char* data, int x, int y, int width, int height, int bpp)
start = y * width + x / 2; start = y * width + x / 2;
shift = x % 2; shift = x % 2;
if (shift == 0) if (shift == 0)
{
return (data[start] & 0xf0) >> 4; return (data[start] & 0xf0) >> 4;
}
else else
{
return data[start] & 0x0f; return data[start] & 0x0f;
}
} }
else if (bpp == 8) else if (bpp == 8)
{ {
@ -173,22 +271,34 @@ void set_pixel_safe(char* data, int x, int y, int width, int height, int bpp,
int shift; int shift;
if (x < 0) if (x < 0)
{
return; return;
}
if (y < 0) if (y < 0)
{
return; return;
}
if (x >= width) if (x >= width)
{
return; return;
}
if (y >= height) if (y >= height)
{
return; return;
}
if (bpp == 1) if (bpp == 1)
{ {
width = (width + 7) / 8; width = (width + 7) / 8;
start = (y * width) + x / 8; start = (y * width) + x / 8;
shift = x % 8; shift = x % 8;
if (pixel & 1) if (pixel & 1)
{
data[start] = data[start] | (0x80 >> shift); data[start] = data[start] | (0x80 >> shift);
}
else else
{
data[start] = data[start] & ~(0x80 >> shift); data[start] = data[start] & ~(0x80 >> shift);
}
} }
else if (bpp == 15 || bpp == 16) else if (bpp == 15 || bpp == 16)
{ {
@ -259,134 +369,117 @@ int lib_framebuffer_update(struct vnc* v)
int b; int b;
int data_size; int data_size;
int need_size; int need_size;
int error;
struct stream* s; struct stream* s;
data_size = 0; data_size = 0;
data = 0; data = 0;
num_recs = 0;
Bpp = (v->mod_bpp + 7) / 8; Bpp = (v->mod_bpp + 7) / 8;
make_stream(s); make_stream(s);
init_stream(s, 8192); init_stream(s, 8192);
if (g_tcp_force_recv(v->sck, s->data, 3) != 0) error = lib_recv(v, s->data, 3);
if (error == 0)
{ {
free_stream(s); in_uint8s(s, 1);
return 1; in_uint16_be(s, num_recs);
error = v->server_begin_update(v);
} }
in_uint8s(s, 1);
in_uint16_be(s, num_recs);
v->server_begin_update(v);
for (i = 0; i < num_recs; i++) for (i = 0; i < num_recs; i++)
{ {
init_stream(s, 8192); if (error != 0)
if (g_tcp_force_recv(v->sck, s->data, 12) != 0)
{ {
free_stream(s); break;
return 1;
} }
in_uint16_be(s, x); init_stream(s, 8192);
in_uint16_be(s, y); error = lib_recv(v, s->data, 12);
in_uint16_be(s, cx); if (error == 0)
in_uint16_be(s, cy); {
in_uint32_be(s, encoding); in_uint16_be(s, x);
if (encoding == 0) /* raw */ in_uint16_be(s, y);
{ in_uint16_be(s, cx);
need_size = cx * cy * Bpp; in_uint16_be(s, cy);
if (need_size > data_size) in_uint32_be(s, encoding);
{ if (encoding == 0) /* raw */
g_free(data);
data = (char*)g_malloc(need_size, 0);
data_size = need_size;
}
if (g_tcp_force_recv(v->sck, data, cx * cy * Bpp) != 0)
{
g_free(data);
free_stream(s);
return 1;
}
if (v->server_paint_rect(v, x, y, cx, cy, data) != 0)
{
g_free(data);
free_stream(s);
return 1;
}
}
else if (encoding == 1) /* copy rect */
{
init_stream(s, 8192);
if (g_tcp_force_recv(v->sck, s->data, 4) != 0)
{
g_free(data);
free_stream(s);
return 1;
}
in_uint16_be(s, srcx);
in_uint16_be(s, srcy);
if (v->server_screen_blt(v, x, y, cx, cy, srcx, srcy) != 0)
{ {
g_free(data); need_size = cx * cy * Bpp;
free_stream(s); if (need_size > data_size)
return 1; {
g_free(data);
data = (char*)g_malloc(need_size, 0);
data_size = need_size;
}
error = lib_recv(v, data, need_size);
/*g_printf("%d %d\n", i, need_size);*/
if (error == 0)
{
error = v->server_paint_rect(v, x, y, cx, cy, data);
}
} }
} else if (encoding == 1) /* copy rect */
else if (encoding == 0xffffff11) /* cursor */
{
g_memset(cursor_data, 0, 32 * (32 * 3));
g_memset(cursor_mask, 0, 32 * (32 / 8));
init_stream(s, 8192);
if (g_tcp_force_recv(v->sck, s->data,
cx * cy * Bpp + ((cx + 7) / 8) * cy) != 0)
{ {
g_free(data); init_stream(s, 8192);
free_stream(s); error = lib_recv(v, s->data, 4);
return 1; if (error == 0)
{
in_uint16_be(s, srcx);
in_uint16_be(s, srcy);
error = v->server_screen_blt(v, x, y, cx, cy, srcx, srcy);
}
} }
in_uint8p(s, d1, cx * cy * Bpp); else if (encoding == 0xffffff11) /* cursor */
in_uint8p(s, d2, ((cx + 7) / 8) * cy);
for (j = 0; j < 32; j++)
{ {
for (k = 0; k < 32; k++) g_memset(cursor_data, 0, 32 * (32 * 3));
g_memset(cursor_mask, 0, 32 * (32 / 8));
init_stream(s, 8192);
error = lib_recv(v, s->data, cx * cy * Bpp + ((cx + 7) / 8) * cy);
if (error == 0)
{ {
pixel = get_pixel_safe(d2, k, 31 - j, cx, cy, 1); in_uint8p(s, d1, cx * cy * Bpp);
set_pixel_safe(cursor_mask, k, j, 32, 32, 1, !pixel); in_uint8p(s, d2, ((cx + 7) / 8) * cy);
if (pixel) for (j = 0; j < 32; j++)
{ {
pixel = get_pixel_safe(d1, k, 31 - j, cx, cy, v->mod_bpp); for (k = 0; k < 32; k++)
split_color(pixel, &r, &g, &b, v->mod_bpp, v->palette); {
pixel = make_color(r, g, b, 24); pixel = get_pixel_safe(d2, k, 31 - j, cx, cy, 1);
set_pixel_safe(cursor_data, k, j, 32, 32, 24, pixel); set_pixel_safe(cursor_mask, k, j, 32, 32, 1, !pixel);
if (pixel)
{
pixel = get_pixel_safe(d1, k, 31 - j, cx, cy, v->mod_bpp);
split_color(pixel, &r, &g, &b, v->mod_bpp, v->palette);
pixel = make_color(r, g, b, 24);
set_pixel_safe(cursor_data, k, j, 32, 32, 24, pixel);
}
}
} }
error = v->server_set_cursor(v, x, y, cursor_data, cursor_mask);
} }
} }
if (v->server_set_cursor(v, x, y, cursor_data, cursor_mask) != 0) else
{ {
g_free(data); g_printf("error in lib_framebuffer_update\n\r");
free_stream(s);
return 1;
} }
} }
else
{
g_printf("error in lib_framebuffer_update\n\r");
}
} }
v->server_end_update(v); if (error == 0)
{
error = v->server_end_update(v);
}
g_free(data); g_free(data);
if (error == 0)
/* FrambufferUpdateRequest */ {
init_stream(s, 8192); /* FrambufferUpdateRequest */
out_uint8(s, 3); init_stream(s, 8192);
out_uint8(s, 1); out_uint8(s, 3);
out_uint16_be(s, 0); out_uint8(s, 1);
out_uint16_be(s, 0); out_uint16_be(s, 0);
out_uint16_be(s, v->mod_width); out_uint16_be(s, 0);
out_uint16_be(s, v->mod_height); out_uint16_be(s, v->mod_width);
if (g_tcp_force_send(v->sck, s->data, 10) != 0) out_uint16_be(s, v->mod_height);
{ error = lib_send(v, s->data, 10);
free_stream(s);
return 1;
} }
free_stream(s); free_stream(s);
return 0; return error;
} }
/******************************************************************************/ /******************************************************************************/
@ -394,24 +487,20 @@ int lib_clip_data(struct vnc* v)
{ {
struct stream* s; struct stream* s;
int size; int size;
int error;
make_stream(s); make_stream(s);
init_stream(s, 8192); init_stream(s, 8192);
if (g_tcp_force_recv(v->sck, s->data, 7) != 0) error = lib_recv(v, s->data, 7);
{ if (error == 0)
free_stream(s);
return 1;
}
in_uint8s(s, 3);
in_uint32_be(s, size);
init_stream(s, 8192);
if (g_tcp_force_recv(v->sck, s->data, size) != 0)
{ {
free_stream(s); in_uint8s(s, 3);
return 1; in_uint32_be(s, size);
init_stream(s, 8192);
error = lib_recv(v, s->data, size);
} }
free_stream(s); free_stream(s);
return 0; return error;
} }
/******************************************************************************/ /******************************************************************************/
@ -424,83 +513,72 @@ int lib_palette_update(struct vnc* v)
int r; int r;
int g; int g;
int b; int b;
int error;
make_stream(s); make_stream(s);
init_stream(s, 8192); init_stream(s, 8192);
if (g_tcp_force_recv(v->sck, s->data, 5) != 0) error = lib_recv(v, s->data, 5);
if (error == 0)
{ {
free_stream(s); in_uint8s(s, 1);
return 1; in_uint16_be(s, first_color);
in_uint16_be(s, num_colors);
init_stream(s, 8192);
error = lib_recv(v, s->data, num_colors * 6);
} }
in_uint8s(s, 1); if (error == 0)
in_uint16_be(s, first_color);
in_uint16_be(s, num_colors);
init_stream(s, 8192);
if (g_tcp_force_recv(v->sck, s->data, num_colors * 6) != 0)
{ {
free_stream(s); for (i = 0; i < num_colors; i++)
return 1; {
in_uint16_be(s, r);
in_uint16_be(s, g);
in_uint16_be(s, b);
r = r >> 8;
g = g >> 8;
b = b >> 8;
v->palette[first_color + i] = (r << 16) | (g << 8) | b;
}
error = v->server_begin_update(v);
}
if (error == 0)
{
error = v->server_palette(v, v->palette);
} }
for (i = 0; i < num_colors; i++) if (error == 0)
{ {
in_uint16_be(s, r); error = v->server_end_update(v);
in_uint16_be(s, g);
in_uint16_be(s, b);
r = r >> 8;
g = g >> 8;
b = b >> 8;
v->palette[first_color + i] = (r << 16) | (g << 8) | b;
} }
v->server_begin_update(v);
v->server_palette(v, v->palette);
v->server_end_update(v);
free_stream(s); free_stream(s);
return 0; return error;
} }
/******************************************************************************/ /******************************************************************************/
int lib_mod_signal(struct vnc* v) int lib_mod_signal(struct vnc* v)
{ {
char type; char type;
int error;
if (g_tcp_force_recv(v->sck, &type, 1) != 0) error = lib_recv(v, &type, 1);
{ if (error == 0)
g_tcp_close(v->sck);
v->sck = 0;
return 1;
}
if (type == 0) /* framebuffer update */
{ {
if (lib_framebuffer_update(v) != 0) if (type == 0) /* framebuffer update */
{ {
g_tcp_close(v->sck); error = lib_framebuffer_update(v);
v->sck = 0;
return 1;
} }
} else if (type == 1) /* palette */
else if (type == 1) /* palette */
{
if (lib_palette_update(v) != 0)
{ {
g_tcp_close(v->sck); error = lib_palette_update(v);
v->sck = 0;
return 1;
} }
} else if (type == 3) /* clipboard */
else if (type == 3) /* clipboard */
{
if (lib_clip_data(v) != 0)
{ {
g_tcp_close(v->sck); error = lib_clip_data(v);
v->sck = 0; }
return 1; else
{
g_printf("unknown in lib_mod_signal %d\n\r", type);
} }
} }
else return error;
{
g_printf("unknown in lib_mod_signal %d\n\r", type);
}
return 0;
} }
/******************************************************************************/ /******************************************************************************/
@ -536,7 +614,6 @@ int lib_mod_connect(struct vnc* v)
int error; int error;
int i; int i;
int check_sec_result; int check_sec_result;
int sck;
int version; int version;
int size; int size;
int code; int code;
@ -554,8 +631,9 @@ int lib_mod_connect(struct vnc* v)
i = 0; i = 0;
error = 0; error = 0;
init_stream(s, 8192); init_stream(s, 8192);
sck = g_tcp_socket(); v->sck = g_tcp_socket();
if (g_tcp_connect(sck, v->ip, "3350") == 0) v->sck_closed = 0;
if (g_tcp_connect(v->sck, v->ip, "3350") == 0)
{ {
s_push_layer(s, channel_hdr, 8); s_push_layer(s, channel_hdr, 8);
out_uint16_be(s, 0); // code out_uint16_be(s, 0); // code
@ -572,49 +650,37 @@ int lib_mod_connect(struct vnc* v)
s_pop_layer(s, channel_hdr); s_pop_layer(s, channel_hdr);
out_uint32_be(s, 0); // version out_uint32_be(s, 0); // version
out_uint32_be(s, s->end - s->data); // size out_uint32_be(s, s->end - s->data); // size
if (g_tcp_force_send(sck, s->data, s->end - s->data) != 0) error = lib_send(v, s->data, s->end - s->data);
if (error == 0)
{ {
g_tcp_close(sck); init_stream(s, 8192);
free_stream(s); error = lib_recv(v, s->data, 8);
return 7;
} }
init_stream(s, 8192); if (error == 0)
if (g_tcp_force_recv(sck, s->data, 8) == 0)
{ {
in_uint32_be(s, version); in_uint32_be(s, version);
in_uint32_be(s, size); in_uint32_be(s, size);
init_stream(s, 8192); init_stream(s, 8192);
if (g_tcp_force_recv(sck, s->data, size - 8) == 0) error = lib_recv(v, s->data, size - 8);
}
if (error == 0)
{
if (version == 0)
{ {
if (version == 0) in_uint16_be(s, code);
if (code == 3)
{ {
in_uint16_be(s, code); in_uint16_be(s, ok);
if (code == 3) in_uint16_be(s, display);
if (ok)
{ {
in_uint16_be(s, ok); i = display;
in_uint16_be(s, display);
if (ok)
{
i = display;
}
} }
} }
} }
else
{
g_tcp_close(sck);
free_stream(s);
return 7;
}
}
else
{
g_tcp_close(sck);
free_stream(s);
return 7;
} }
} }
g_tcp_close(sck); g_tcp_close(v->sck);
if (error != 0 || i == 0) if (error != 0 || i == 0)
{ {
free_stream(s); free_stream(s);
@ -629,128 +695,87 @@ int lib_mod_connect(struct vnc* v)
} }
make_stream(pixel_format); make_stream(pixel_format);
v->sck = g_tcp_socket(); v->sck = g_tcp_socket();
v->sck_closed = 0;
error = g_tcp_connect(v->sck, v->ip, con_port); error = g_tcp_connect(v->sck, v->ip, con_port);
if (error == 0) if (error == 0)
{ {
g_tcp_set_non_blocking(v->sck); g_tcp_set_non_blocking(v->sck);
g_tcp_set_no_delay(v->sck);
/* protocal version */ /* protocal version */
init_stream(s, 8192); init_stream(s, 8192);
if (g_tcp_force_recv(v->sck, s->data, 12) != 0) error = lib_recv(v, s->data, 12);
if (error == 0)
{ {
g_tcp_close(v->sck); error = lib_send(v, "RFB 003.003\n", 12);
v->sck = 0;
free_stream(s);
free_stream(pixel_format);
return 7;
}
if (g_tcp_force_send(v->sck, "RFB 003.003\n", 12) != 0)
{
g_tcp_close(v->sck);
v->sck = 0;
free_stream(s);
free_stream(pixel_format);
return 7;
} }
/* sec type */ /* sec type */
init_stream(s, 8192); if (error == 0)
if (g_tcp_force_recv(v->sck, s->data, 4) != 0)
{ {
g_tcp_close(v->sck); init_stream(s, 8192);
v->sck = 0; error = lib_recv(v, s->data, 4);
free_stream(s);
free_stream(pixel_format);
return 7;
}
in_uint32_be(s, i);
if (i == 1) /* none */
{
check_sec_result = 0;
} }
else if (i == 2) /* dec the password and the server random */ if (error == 0)
{ {
init_stream(s, 8192); in_uint32_be(s, i);
if (g_tcp_force_recv(v->sck, s->data, 16) != 0) if (i == 1) /* none */
{
check_sec_result = 0;
}
else if (i == 2) /* dec the password and the server random */
{ {
g_tcp_close(v->sck); init_stream(s, 8192);
v->sck = 0; error = lib_recv(v, s->data, 16);
free_stream(s); if (error == 0)
free_stream(pixel_format); {
return 7; rfbEncryptBytes((unsigned char*)s->data, v->password);
error = lib_send(v, s->data, 16);
}
} }
rfbEncryptBytes((unsigned char*)s->data, v->password); else
if (g_tcp_force_send(v->sck, s->data, 16) != 0)
{ {
g_tcp_close(v->sck); error = 1;
v->sck = 0;
free_stream(s);
free_stream(pixel_format);
return 7;
} }
} }
else
{
error = 1;
}
} }
if (error == 0 && check_sec_result) if (error == 0 && check_sec_result)
{ {
/* sec result */ /* sec result */
init_stream(s, 8192); init_stream(s, 8192);
if (g_tcp_force_recv(v->sck, s->data, 4) != 0) error = lib_recv(v, s->data, 4);
if (error == 0)
{ {
g_tcp_close(v->sck); in_uint32_be(s, i);
v->sck = 0; if (i != 0)
free_stream(s); {
free_stream(pixel_format); error = 2;
return 7; }
}
in_uint32_be(s, i);
if (i != 0)
{
error = 2;
} }
} }
if (error == 0) if (error == 0)
{ {
init_stream(s, 8192); init_stream(s, 8192);
s->data[0] = 1; s->data[0] = 1;
if (g_tcp_force_send(v->sck, s->data, 1) != 0) /* share flag */ error = lib_send(v, s->data, 1); /* share flag */
{ }
g_tcp_close(v->sck); if (error == 0)
v->sck = 0; {
free_stream(s); error = lib_recv(v, s->data, 4); /* server init */
free_stream(pixel_format); }
return 7; if (error == 0)
} {
if (g_tcp_force_recv(v->sck, s->data, 4) != 0) /* server init */
{
g_tcp_close(v->sck);
v->sck = 0;
free_stream(s);
free_stream(pixel_format);
return 7;
}
in_uint16_be(s, v->mod_width); in_uint16_be(s, v->mod_width);
in_uint16_be(s, v->mod_height); in_uint16_be(s, v->mod_height);
init_stream(pixel_format, 8192); init_stream(pixel_format, 8192);
if (g_tcp_force_recv(v->sck, pixel_format->data, 16) != 0) error = lib_recv(v, pixel_format->data, 16);
{ }
g_tcp_close(v->sck); if (error == 0)
v->sck = 0; {
free_stream(s);
free_stream(pixel_format);
return 7;
}
in_uint8(pixel_format, v->mod_bpp); in_uint8(pixel_format, v->mod_bpp);
init_stream(s, 8192); init_stream(s, 8192);
if (g_tcp_force_recv(v->sck, s->data, 4) != 0) /* name len */ error = lib_recv(v, s->data, 4); /* name len */
{ }
g_tcp_close(v->sck); if (error == 0)
v->sck = 0; {
free_stream(s);
free_stream(pixel_format);
return 7;
}
in_uint32_be(s, i); in_uint32_be(s, i);
if (i > 255 || i < 0) if (i > 255 || i < 0)
{ {
@ -758,18 +783,11 @@ int lib_mod_connect(struct vnc* v)
} }
else else
{ {
if (g_tcp_force_recv(v->sck, v->mod_name, i) != 0) error = lib_recv(v, v->mod_name, i);
{
g_tcp_close(v->sck);
v->sck = 0;
free_stream(s);
free_stream(pixel_format);
return 7;
}
v->mod_name[i] = 0; v->mod_name[i] = 0;
} }
/* should be connected */
} }
/* should be connected */
if (error == 0) if (error == 0)
{ {
/* SetPixelFormat */ /* SetPixelFormat */
@ -794,14 +812,10 @@ int lib_mod_connect(struct vnc* v)
out_uint8s(pixel_format, 3); /* pad */ out_uint8s(pixel_format, 3); /* pad */
} }
out_uint8a(s, pixel_format->data, 16); out_uint8a(s, pixel_format->data, 16);
if (g_tcp_force_send(v->sck, s->data, 20) != 0) error = lib_send(v, s->data, 20);
{ }
g_tcp_close(v->sck); if (error == 0)
v->sck = 0; {
free_stream(s);
free_stream(pixel_format);
return 7;
}
/* SetEncodings */ /* SetEncodings */
init_stream(s, 8192); init_stream(s, 8192);
out_uint8(s, 2); out_uint8(s, 2);
@ -810,14 +824,10 @@ int lib_mod_connect(struct vnc* v)
out_uint32_be(s, 0); /* raw */ out_uint32_be(s, 0); /* raw */
out_uint32_be(s, 1); /* copy rect */ out_uint32_be(s, 1); /* copy rect */
out_uint32_be(s, 0xffffff11); /* cursor */ out_uint32_be(s, 0xffffff11); /* cursor */
if (g_tcp_force_send(v->sck, s->data, 4 + 3 * 4) != 0) error = lib_send(v, s->data, 4 + 3 * 4);
{ }
g_tcp_close(v->sck); if (error == 0)
v->sck = 0; {
free_stream(s);
free_stream(pixel_format);
return 7;
}
/* FrambufferUpdateRequest */ /* FrambufferUpdateRequest */
init_stream(s, 8192); init_stream(s, 8192);
out_uint8(s, 3); out_uint8(s, 3);
@ -826,14 +836,7 @@ int lib_mod_connect(struct vnc* v)
out_uint16_be(s, 0); out_uint16_be(s, 0);
out_uint16_be(s, v->mod_width); out_uint16_be(s, v->mod_width);
out_uint16_be(s, v->mod_height); out_uint16_be(s, v->mod_height);
if (g_tcp_force_send(v->sck, s->data, 10) != 0) error = lib_send(v, s->data, 10);
{
g_tcp_close(v->sck);
v->sck = 0;
free_stream(s);
free_stream(pixel_format);
return 7;
}
} }
if (error == 0) if (error == 0)
{ {
@ -843,46 +846,19 @@ int lib_mod_connect(struct vnc* v)
error = 4; error = 4;
} }
} }
/* set almost null cursor */ if (error == 0)
g_memset(cursor_data, 0, 32 * (32 * 3));
g_memset(cursor_data + (32 * (32 * 3) - 1 * 32 * 3), 0xff, 9);
g_memset(cursor_data + (32 * (32 * 3) - 2 * 32 * 3), 0xff, 9);
g_memset(cursor_data + (32 * (32 * 3) - 3 * 32 * 3), 0xff, 9);
g_memset(cursor_mask, 0xff, 32 * (32 / 8));
v->server_set_cursor(v, 0, 0, cursor_data, cursor_mask);
free_stream(s);
free_stream(pixel_format);
if (error != 0)
{ {
g_tcp_close(v->sck); /* set almost null cursor */
v->sck = 0; g_memset(cursor_data, 0, 32 * (32 * 3));
} g_memset(cursor_data + (32 * (32 * 3) - 1 * 32 * 3), 0xff, 9);
return error; g_memset(cursor_data + (32 * (32 * 3) - 2 * 32 * 3), 0xff, 9);
} g_memset(cursor_data + (32 * (32 * 3) - 3 * 32 * 3), 0xff, 9);
g_memset(cursor_mask, 0xff, 32 * (32 / 8));
/******************************************************************************/ error = v->server_set_cursor(v, 0, 0, cursor_data, cursor_mask);
int lib_mod_invalidate(struct vnc* v, int x, int y, int cx, int cy)
{
struct stream* s;
make_stream(s);
/* FrambufferUpdateRequest */
init_stream(s, 8192);
out_uint8(s, 3);
out_uint8(s, 0);
out_uint16_be(s, x);
out_uint16_be(s, y);
out_uint16_be(s, cx);
out_uint16_be(s, cy);
if (g_tcp_force_send(v->sck, s->data, 10) != 0)
{
free_stream(s);
g_tcp_close(v->sck);
v->sck = 0;
return 1;
} }
free_stream(s); free_stream(s);
return 0; free_stream(pixel_format);
return error;
} }
/******************************************************************************/ /******************************************************************************/
@ -924,12 +900,11 @@ int mod_init()
v = (struct vnc*)g_malloc(sizeof(struct vnc), 1); v = (struct vnc*)g_malloc(sizeof(struct vnc), 1);
/* set client functions */ /* set client functions */
v->size = sizeof(struct vnc); v->size = sizeof(struct vnc);
v->handle = (int)v; v->handle = (long)v;
v->mod_connect = lib_mod_connect; v->mod_connect = lib_mod_connect;
v->mod_start = lib_mod_start; v->mod_start = lib_mod_start;
v->mod_event = lib_mod_event; v->mod_event = lib_mod_event;
v->mod_signal = lib_mod_signal; v->mod_signal = lib_mod_signal;
v->mod_invalidate = lib_mod_invalidate;
v->mod_end = lib_mod_end; v->mod_end = lib_mod_end;
v->mod_set_param = lib_mod_set_param; v->mod_set_param = lib_mod_set_param;
return (int)v; return (int)v;
@ -939,7 +914,9 @@ int mod_init()
int mod_exit(struct vnc* v) int mod_exit(struct vnc* v)
{ {
if (v == 0) if (v == 0)
{
return 0; return 0;
}
g_tcp_close(v->sck); g_tcp_close(v->sck);
g_free(v); g_free(v);
return 0; return 0;

12
vnc/vnc.h
Unescape View File

@ -14,7 +14,7 @@
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
xrdp: A Remote Desktop Protocol server. xrdp: A Remote Desktop Protocol server.
Copyright (C) Jay Sorg 2004 Copyright (C) Jay Sorg 2004-2005
libvnc libvnc
@ -35,10 +35,8 @@ struct vnc
int (*mod_connect)(struct vnc* v); int (*mod_connect)(struct vnc* v);
int (*mod_event)(struct vnc* v, int msg, int param1, int param2); int (*mod_event)(struct vnc* v, int msg, int param1, int param2);
int (*mod_signal)(struct vnc* v); int (*mod_signal)(struct vnc* v);
int (*mod_invalidate)(struct vnc* v, int x, int y, int cx, int cy);
int (*mod_end)(struct vnc* v); int (*mod_end)(struct vnc* v);
int (*mod_set_param)(struct vnc* v, char* name, char* value); int (*mod_set_param)(struct vnc* v, char* name, char* value);
int d1[93];
/* server functions */ /* server functions */
int (*server_begin_update)(struct vnc* v); int (*server_begin_update)(struct vnc* v);
int (*server_end_update)(struct vnc* v); int (*server_end_update)(struct vnc* v);
@ -51,11 +49,10 @@ struct vnc
int (*server_set_cursor)(struct vnc* v, int x, int y, char* data, char* mask); int (*server_set_cursor)(struct vnc* v, int x, int y, char* data, char* mask);
int (*server_palette)(struct vnc* v, int* palette); int (*server_palette)(struct vnc* v, int* palette);
int (*server_error_popup)(struct vnc* v, char* error, char* caption); int (*server_error_popup)(struct vnc* v, char* error, char* caption);
int d2[92];
/* common */ /* common */
int handle; /* pointer to self as int */ long handle; /* pointer to self as int */
int wm; long wm;
int painter; long painter;
int sck; int sck;
/* mod data */ /* mod data */
int server_width; int server_width;
@ -72,4 +69,5 @@ struct vnc
char password[256]; char password[256];
char ip[256]; char ip[256];
char port[256]; char port[256];
int sck_closed;
}; };

1
xrdp/constants.h
Unescape View File

@ -428,3 +428,4 @@
#define WM_BUTTON4DOWN 108 #define WM_BUTTON4DOWN 108
#define WM_BUTTON5UP 109 #define WM_BUTTON5UP 109
#define WM_BUTTON5DOWN 110 #define WM_BUTTON5DOWN 110
#define WM_INVALIDATE 200

2
xrdp/xrdp.c
Unescape View File

@ -34,7 +34,7 @@ THREAD_RV THREAD_CC xrdp_listen_run(void* in_val)
return 0; return 0;
} }
//#define CLEAN_CLOSE #define CLEAN_CLOSE
/*****************************************************************************/ /*****************************************************************************/
int main(int argc, char** argv) int main(int argc, char** argv)

12
xrdp/xrdp_bitmap.c
Unescape View File

@ -891,14 +891,16 @@ int xrdp_bitmap_invalidate(struct xrdp_bitmap* self, struct xrdp_rect* rect)
{ {
if (self->wm->mod != 0) if (self->wm->mod != 0)
{ {
if (self->wm->mod->mod_invalidate != 0) if (self->wm->mod->mod_event != 0)
{ {
if (rect != 0) if (rect != 0)
{ {
self->wm->mod->mod_invalidate(self->wm->mod, x = rect->left;
rect->left, rect->top, y = rect->top;
rect->right - rect->left, w = rect->right - rect->left;
rect->bottom - rect->top); h = rect->bottom - rect->top;
self->wm->mod->mod_event(self->wm->mod, WM_INVALIDATE, /* 200 */
MAKELONG(x, y), MAKELONG(w, h));
} }
} }
} }

8
xrdp/xrdp_interface.c
Unescape View File

@ -50,7 +50,7 @@ int server_init(void)
g_rdp_process = 0; g_rdp_process = 0;
make_stream(g_s); make_stream(g_s);
init_stream(g_s, 8192); init_stream(g_s, 8192);
g_mod.handle = (int)(&g_mod); g_mod.handle = (long)(&g_mod);
g_mod.mod_event = mod_event; g_mod.mod_event = mod_event;
return 0; return 0;
} }
@ -107,7 +107,7 @@ int server_loop(int sck)
} }
if (g_mod.wm == 0) if (g_mod.wm == 0)
{ {
g_mod.wm = (int)(g_rdp_process->wm); g_mod.wm = (long)(g_rdp_process->wm);
} }
} }
init_stream(g_s, 8192); init_stream(g_s, 8192);
@ -134,7 +134,7 @@ int server_begin_update(void)
wm = (struct xrdp_wm*)g_mod.wm; wm = (struct xrdp_wm*)g_mod.wm;
p = xrdp_painter_create(wm); p = xrdp_painter_create(wm);
xrdp_painter_begin_update(p); xrdp_painter_begin_update(p);
g_mod.painter = (int)p; g_mod.painter = (long)p;
return 0; return 0;
} }
@ -224,7 +224,7 @@ int server_begin_update(struct xrdp_mod* mod)
wm = (struct xrdp_wm*)mod->wm; wm = (struct xrdp_wm*)mod->wm;
p = xrdp_painter_create(wm); p = xrdp_painter_create(wm);
xrdp_painter_begin_update(p); xrdp_painter_begin_update(p);
mod->painter = (int)p; mod->painter = (long)p;
return 0; return 0;
} }

2
xrdp/xrdp_login_wnd.c
Unescape View File

@ -101,7 +101,7 @@ int xrdp_wm_setup_mod(struct xrdp_wm* self,
} }
if (self->mod != 0) if (self->mod != 0)
{ {
self->mod->wm = (int)self; self->mod->wm = (long)self;
self->mod->server_begin_update = server_begin_update; self->mod->server_begin_update = server_begin_update;
self->mod->server_end_update = server_end_update; self->mod->server_end_update = server_end_update;
self->mod->server_fill_rect = server_fill_rect; self->mod->server_fill_rect = server_fill_rect;

12
xrdp/xrdp_painter.c
Unescape View File

@ -555,10 +555,20 @@ int xrdp_painter_draw_text(struct xrdp_painter* self,
draw_rect.right--; draw_rect.right--;
draw_rect.bottom--; draw_rect.bottom--;
flags = 0x03; /* 0x73; TEXT2_IMPLICIT_X and something else */ flags = 0x03; /* 0x73; TEXT2_IMPLICIT_X and something else */
DEBUG(("sending text order \
font %d flags %d mixmode %d color1 %d color2 %d \
clip left %d clip top %d clip right %d clip bottom %d \
box left %d box top %d box right %d box bottom %d \
x %d y %d len %d rect %d %d %d %d\n\r",
f, flags, 0, font->color, 0, x, y, x + total_width,
y + total_height, 0, 0, 0, 0, x1, y1, len,
draw_rect.left, draw_rect.top,
draw_rect.right, draw_rect.bottom));
xrdp_orders_text(self->orders, f, flags, 0, xrdp_orders_text(self->orders, f, flags, 0,
font->color, 0, font->color, 0,
x, y, x + total_width, y + total_height, x, y, x + total_width, y + total_height,
0, 0, 0, 0, x1, y1, data, len * 2, &draw_rect); 0, 0, 0, 0,
x1, y1, data, len * 2, &draw_rect);
} }
} }
k++; k++;

24
xrdp/xrdp_process.c
Unescape View File

@ -105,7 +105,7 @@ int xrdp_process_loop(struct xrdp_process* self, struct stream* s)
int xrdp_process_main_loop(struct xrdp_process* self) int xrdp_process_main_loop(struct xrdp_process* self)
{ {
#ifndef XRDP_LIB #ifndef XRDP_LIB
int i; int sel_r;
struct stream* s; struct stream* s;
make_stream(s); make_stream(s);
@ -117,8 +117,16 @@ int xrdp_process_main_loop(struct xrdp_process* self)
{ {
while (!g_is_term() && !self->term) while (!g_is_term() && !self->term)
{ {
i = g_tcp_select(self->sck, self->app_sck); sel_r = g_tcp_select(self->sck, self->app_sck);
if (i & 1) if (sel_r == 0) /* no data on any stream */
{
g_sleep(10);
}
else if (sel_r < 0)
{
break;
}
if (sel_r & 1)
{ {
init_stream(s, 8192); init_stream(s, 8192);
if (xrdp_process_loop(self, s) != 0) if (xrdp_process_loop(self, s) != 0)
@ -126,7 +134,7 @@ int xrdp_process_main_loop(struct xrdp_process* self)
break; break;
} }
} }
if (i & 2) /* mod socket fired */ if (sel_r & 2) /* mod socket fired */
{ {
if (self->wm->mod == 0) if (self->wm->mod == 0)
{ {
@ -141,14 +149,6 @@ int xrdp_process_main_loop(struct xrdp_process* self)
break; break;
} }
} }
if (i == 0) /* no data on any stream */
{
g_sleep(10);
}
else if (i < 0)
{
break;
}
} }
} }
if (self->wm->mod != 0) if (self->wm->mod != 0)

2
xrdp/xrdp_tcp.c
Unescape View File

@ -77,6 +77,7 @@ int xrdp_tcp_recv(struct xrdp_tcp* self, struct stream* s, int len)
} }
else else
{ {
self->sck_closed = 1;
DEBUG((" error = -1 in xrdp_tcp_recv socket %d\n\r", self->sck)); DEBUG((" error = -1 in xrdp_tcp_recv socket %d\n\r", self->sck));
return 1; return 1;
} }
@ -128,6 +129,7 @@ int xrdp_tcp_send(struct xrdp_tcp* self, struct stream* s)
} }
else else
{ {
self->sck_closed = 1;
DEBUG((" error = -1 in xrdp_tcp_send socket %d\n\r", self->sck)); DEBUG((" error = -1 in xrdp_tcp_send socket %d\n\r", self->sck));
return 1; return 1;
} }

27
xrdp/xrdp_types.h
Unescape View File

@ -29,10 +29,8 @@ struct xrdp_mod
int (*mod_connect)(struct xrdp_mod* v); int (*mod_connect)(struct xrdp_mod* v);
int (*mod_event)(struct xrdp_mod* v, int msg, int param1, int param2); int (*mod_event)(struct xrdp_mod* v, int msg, int param1, int param2);
int (*mod_signal)(struct xrdp_mod* v); int (*mod_signal)(struct xrdp_mod* v);
int (*mod_invalidate)(struct xrdp_mod* v, int x, int y, int cx, int cy);
int (*mod_end)(struct xrdp_mod* v); int (*mod_end)(struct xrdp_mod* v);
int (*mod_set_param)(struct xrdp_mod* v, char* name, char* value); int (*mod_set_param)(struct xrdp_mod* v, char* name, char* value);
int d1[93];
/* server functions */ /* server functions */
int (*server_begin_update)(struct xrdp_mod* v); int (*server_begin_update)(struct xrdp_mod* v);
int (*server_end_update)(struct xrdp_mod* v); int (*server_end_update)(struct xrdp_mod* v);
@ -45,11 +43,10 @@ struct xrdp_mod
int (*server_set_pointer)(struct xrdp_mod* v, int x, int y, char* data, char* mask); int (*server_set_pointer)(struct xrdp_mod* v, int x, int y, char* data, char* mask);
int (*server_palette)(struct xrdp_mod* v, int* palette); int (*server_palette)(struct xrdp_mod* v, int* palette);
int (*server_error_popup)(struct xrdp_mod* v, char* error, char* caption); int (*server_error_popup)(struct xrdp_mod* v, char* error, char* caption);
int d2[92];
/* common */ /* common */
int handle; /* pointer to self as int */ long handle; /* pointer to self as int */
int wm; /* struct xrdp_wm* */ long wm; /* struct xrdp_wm* */
int painter; long painter;
int sck; int sck;
}; };
@ -63,17 +60,17 @@ struct xrdp_mem
/* header for bmp file */ /* header for bmp file */
struct xrdp_bmp_header struct xrdp_bmp_header
{ {
long size; int size;
long image_width; int image_width;
long image_height; int image_height;
short planes; short planes;
short bit_count; short bit_count;
long compression; int compression;
long image_size; int image_size;
long x_pels_per_meter; int x_pels_per_meter;
long y_pels_per_meter; int y_pels_per_meter;
long clr_used; int clr_used;
long clr_important; int clr_important;
}; };
/* list */ /* list */

Write Preview
Loading…
Cancel
Save