moved a bunch of files around

ulab-original
jsorg71 20 years ago
parent 41df89c7f2
commit 992dbfa7b3

@ -5,17 +5,20 @@ all: world
world:
make -C vnc
make -C libxrdp
make -C xrdp
make -C sesman
clean:
make -C vnc clean
make -C libxrdp clean
make -C xrdp clean
make -C sesman clean
install:
mkdir -p $(DESTDIR)
install xrdp/xrdp $(DESTDIR)/xrdp
install libxrdp/libxrdp.so $(DESTDIR)/libxrdp.so
install xrdp/ad256.bmp $(DESTDIR)/ad256.bmp
install xrdp/xrdp256.bmp $(DESTDIR)/xrdp256.bmp
install xrdp/cursor0.cur $(DESTDIR)/cursor0.cur

@ -0,0 +1,25 @@
LIBXRDPOBJ = libxrdp.o xrdp_tcp.o xrdp_iso.o xrdp_mcs.o \
xrdp_sec.o xrdp_rdp.o xrdp_orders.o \
xrdp_bitmap_compress.o \
../common/os_calls.o \
../common/ssl_calls.o
CFLAGS = -Wall -O2 -I../common -fPIC
LDFLAGS = -shared
LIBS = -ldl -lcrypto
CC = gcc
all: libxrdp
static: $(LIBXRDPOBJ)
$(AR) rvu libxrdp.a $(LIBXRDPOBJ)
ranlib libxrdp.a
libxrdp: $(LIBXRDPOBJ)
$(CC) $(LDFLAGS) -o libxrdp.so $(LIBXRDPOBJ) $(LIBS)
strip libxrdp.so
clean:
rm -f $(LIBXRDPOBJ) libxrdp.a libxrdp.so

@ -0,0 +1,530 @@
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
xrdp: A Remote Desktop Protocol server.
Copyright (C) Jay Sorg 2004-2005
this is the interface to libxrdp
*/
#include "libxrdp.h"
/******************************************************************************/
struct xrdp_session* EXPORT_CC
libxrdp_init(long id, int sck)
{
struct xrdp_session* session;
session = (struct xrdp_session*)g_malloc(sizeof(struct xrdp_session), 1);
session->id = id;
session->rdp = xrdp_rdp_create(session, sck);
session->orders = xrdp_orders_create(session, (struct xrdp_rdp*)session->rdp);
session->client_info = &(((struct xrdp_rdp*)session->rdp)->client_info);
return session;
}
/******************************************************************************/
int EXPORT_CC
libxrdp_exit(struct xrdp_session* session)
{
if (session == 0)
{
return 0;
}
xrdp_orders_delete((struct xrdp_orders*)session->orders);
xrdp_rdp_delete((struct xrdp_rdp*)session->rdp);
g_free(session);
return 0;
}
/******************************************************************************/
int EXPORT_CC
libxrdp_disconnect(struct xrdp_session* session)
{
return xrdp_rdp_disconnect((struct xrdp_rdp*)session->rdp);
}
/******************************************************************************/
int EXPORT_CC
libxrdp_process_incomming(struct xrdp_session* session)
{
return xrdp_rdp_incoming((struct xrdp_rdp*)session->rdp);
}
/******************************************************************************/
int EXPORT_CC
libxrdp_process_data(struct xrdp_session* session)
{
struct stream* s;
int cont;
int rv;
int code;
cont = 1;
rv = 0;
make_stream(s);
init_stream(s, 8192);
while (cont && !session->term)
{
code = 0;
if (xrdp_rdp_recv((struct xrdp_rdp*)session->rdp, s, &code) != 0)
{
rv = 1;
break;
}
DEBUG(("libxrdp_process_data code %d\n\r", code));
switch (code)
{
case -1:
xrdp_rdp_send_demand_active((struct xrdp_rdp*)session->rdp);
break;
case 0:
break;
case RDP_PDU_CONFIRM_ACTIVE: /* 3 */
xrdp_rdp_process_confirm_active((struct xrdp_rdp*)session->rdp, s);
break;
case RDP_PDU_DATA: /* 7 */
if (xrdp_rdp_process_data((struct xrdp_rdp*)session->rdp, s) != 0)
{
DEBUG(("libxrdp_process_data returned non zero\n\r"));
cont = 0;
session->term = 1;
}
break;
default:
g_printf("unknown in libxrdp_process_data\n\r");
break;
}
if (cont)
{
cont = s->next_packet < s->end;
}
}
free_stream(s);
return rv;
}
/******************************************************************************/
int EXPORT_CC
libxrdp_send_palette(struct xrdp_session* session, int* palette)
{
int i;
int color;
struct stream* s;
if (session->client_info->bpp > 8)
{
return 0;
}
/* clear orders */
libxrdp_orders_force_send(session);
make_stream(s);
init_stream(s, 8192);
xrdp_rdp_init_data((struct xrdp_rdp*)session->rdp, s);
out_uint16_le(s, RDP_UPDATE_PALETTE);
out_uint16_le(s, 0);
out_uint16_le(s, 256); /* # of colors */
out_uint16_le(s, 0);
for (i = 0; i < 256; i++)
{
color = palette[i];
out_uint8(s, color >> 16);
out_uint8(s, color >> 8);
out_uint8(s, color);
}
s_mark_end(s);
xrdp_rdp_send_data((struct xrdp_rdp*)session->rdp, s, RDP_DATA_PDU_UPDATE);
free_stream(s);
/* send the orders palette too */
libxrdp_orders_init(session);
libxrdp_orders_send_palette(session, palette, 0);
libxrdp_orders_send(session);
return 0;
}
/*****************************************************************************/
int EXPORT_CC
libxrdp_send_bitmap(struct xrdp_session* session, int width, int height,
int bpp, char* data, int x, int y, int cx, int cy)
{
int data_size;
int line_size;
int i;
int j;
int total_lines;
int lines_sending;
int Bpp;
int e;
int bufsize;
int total_bufsize;
int num_updates;
char* p_num_updates;
char* p;
char* q;
struct stream* s;
struct stream* temp_s;
Bpp = (bpp + 7) / 8;
e = width % 4;
if (e != 0)
{
e = 4 - e;
}
line_size = width * Bpp;
make_stream(s);
init_stream(s, 8192);
if (session->client_info->use_bitmap_comp)
{
make_stream(temp_s);
init_stream(temp_s, 65536);
i = 0;
if (cy <= height)
{
i = cy;
}
while (i > 0)
{
total_bufsize = 0;
num_updates = 0;
xrdp_rdp_init_data((struct xrdp_rdp*)session->rdp, s);
out_uint16_le(s, RDP_UPDATE_BITMAP);
p_num_updates = s->p;
out_uint8s(s, 2); /* num_updates set later */
do
{
if (session->client_info->op1)
{
s_push_layer(s, channel_hdr, 18);
}
else
{
s_push_layer(s, channel_hdr, 26);
}
p = s->p;
lines_sending = xrdp_bitmap_compress(data, width, height,
s, bpp,
4096 - total_bufsize,
i - 1, temp_s, e);
if (lines_sending == 0)
{
break;
}
num_updates++;
bufsize = s->p - p;
total_bufsize += bufsize;
i = i - lines_sending;
s_mark_end(s);
s_pop_layer(s, channel_hdr);
out_uint16_le(s, x); /* left */
out_uint16_le(s, y + i); /* top */
out_uint16_le(s, (x + cx) - 1); /* right */
out_uint16_le(s, (y + i + lines_sending) - 1); /* bottom */
out_uint16_le(s, width + e); /* width */
out_uint16_le(s, lines_sending); /* height */
out_uint16_le(s, bpp); /* bpp */
if (session->client_info->op1)
{
out_uint16_le(s, 0x401); /* compress */
out_uint16_le(s, bufsize); /* compressed size */
j = (width + e) * Bpp;
j = j * lines_sending;
}
else
{
out_uint16_le(s, 0x1); /* compress */
out_uint16_le(s, bufsize + 8);
out_uint8s(s, 2); /* pad */
out_uint16_le(s, bufsize); /* compressed size */
j = (width + e) * Bpp;
out_uint16_le(s, j); /* line size */
j = j * lines_sending;
out_uint16_le(s, j); /* final size */
}
if (j > 32768)
{
g_printf("error, decompressed size too big, its %d\n\r", j);
}
if (bufsize > 8192)
{
g_printf("error, compressed size too big, its %d\n\r", bufsize);
}
s->p = s->end;
} while (total_bufsize < 4096 && i > 0);
p_num_updates[0] = num_updates;
p_num_updates[1] = num_updates >> 8;
xrdp_rdp_send_data((struct xrdp_rdp*)session->rdp, s,
RDP_DATA_PDU_UPDATE);
if (total_bufsize > 8192)
{
g_printf("error, total compressed size too big, its %d\n\r",
total_bufsize);
}
}
free_stream(temp_s);
}
else
{
lines_sending = 0;
data_size = width * height * Bpp;
total_lines = height;
i = 0;
p = data;
if (line_size > 0 && total_lines > 0)
{
while (i < total_lines)
{
lines_sending = 4096 / (line_size + e * Bpp);
if (i + lines_sending > total_lines)
{
lines_sending = total_lines - i;
}
p = p + line_size * lines_sending;
xrdp_rdp_init_data((struct xrdp_rdp*)session->rdp, s);
out_uint16_le(s, RDP_UPDATE_BITMAP);
out_uint16_le(s, 1); /* num updates */
out_uint16_le(s, x);
out_uint16_le(s, y + i);
out_uint16_le(s, (x + cx) - 1);
out_uint16_le(s, (y + i + lines_sending) - 1);
out_uint16_le(s, width + e);
out_uint16_le(s, lines_sending);
out_uint16_le(s, bpp); /* bpp */
out_uint16_le(s, 0); /* compress */
out_uint16_le(s, (line_size + e * Bpp) * lines_sending); /* bufsize */
q = p;
for (j = 0; j < lines_sending; j++)
{
q = q - line_size;
out_uint8a(s, q, line_size)
out_uint8s(s, e * Bpp);
}
s_mark_end(s);
xrdp_rdp_send_data((struct xrdp_rdp*)session->rdp, s,
RDP_DATA_PDU_UPDATE);
i = i + lines_sending;
}
}
}
free_stream(s);
return 0;
}
/*****************************************************************************/
int EXPORT_CC
libxrdp_send_pointer(struct xrdp_session* session, int cache_idx,
char* data, char* mask, int x, int y)
{
struct stream* s;
char* p;
int i;
int j;
make_stream(s);
init_stream(s, 8192);
xrdp_rdp_init_data((struct xrdp_rdp*)session->rdp, s);
out_uint16_le(s, RDP_POINTER_COLOR);
out_uint16_le(s, 0); /* pad */
out_uint16_le(s, cache_idx); /* cache_idx */
out_uint16_le(s, x);
out_uint16_le(s, y);
out_uint16_le(s, 32);
out_uint16_le(s, 32);
out_uint16_le(s, 128);
out_uint16_le(s, 3072);
p = data;
for (i = 0; i < 32; i++)
{
for (j = 0; j < 32; j++)
{
out_uint8(s, *p);
p++;
out_uint8(s, *p);
p++;
out_uint8(s, *p);
p++;
}
}
out_uint8a(s, mask, 128); /* mask */
s_mark_end(s);
xrdp_rdp_send_data((struct xrdp_rdp*)session->rdp, s, RDP_DATA_PDU_POINTER);
free_stream(s);
return 0;
}
/*****************************************************************************/
int EXPORT_CC
libxrdp_set_pointer(struct xrdp_session* session, int cache_idx)
{
struct stream* s;
make_stream(s);
init_stream(s, 8192);
xrdp_rdp_init_data((struct xrdp_rdp*)session->rdp, s);
out_uint16_le(s, RDP_POINTER_CACHED);
out_uint16_le(s, 0); /* pad */
out_uint16_le(s, cache_idx); /* cache_idx */
s_mark_end(s);
xrdp_rdp_send_data((struct xrdp_rdp*)session->rdp, s, RDP_DATA_PDU_POINTER);
free_stream(s);
return 0;
}
/******************************************************************************/
int EXPORT_CC
libxrdp_orders_init(struct xrdp_session* session)
{
return xrdp_orders_init((struct xrdp_orders*)session->orders);
}
/******************************************************************************/
int EXPORT_CC
libxrdp_orders_send(struct xrdp_session* session)
{
return xrdp_orders_send((struct xrdp_orders*)session->orders);
}
/******************************************************************************/
int EXPORT_CC
libxrdp_orders_force_send(struct xrdp_session* session)
{
return xrdp_orders_force_send((struct xrdp_orders*)session->orders);
}
/******************************************************************************/
int EXPORT_CC
libxrdp_orders_rect(struct xrdp_session* session, int x, int y,
int cx, int cy, int color, struct xrdp_rect* rect)
{
return xrdp_orders_rect((struct xrdp_orders*)session->orders,
x, y, cx, cy, color, rect);
}
/******************************************************************************/
int EXPORT_CC
libxrdp_orders_screen_blt(struct xrdp_session* session, int x, int y,
int cx, int cy, int srcx, int srcy,
int rop, struct xrdp_rect* rect)
{
return xrdp_orders_screen_blt((struct xrdp_orders*)session->orders,
x, y, cx, cy, srcx, srcy, rop, rect);
}
/******************************************************************************/
int EXPORT_CC
libxrdp_orders_pat_blt(struct xrdp_session* session, int x, int y,
int cx, int cy, int rop, int bg_color,
int fg_color, struct xrdp_brush* brush,
struct xrdp_rect* rect)
{
return xrdp_orders_pat_blt((struct xrdp_orders*)session->orders,
x, y, cx, cy, rop, bg_color, fg_color,
brush, rect);
}
/******************************************************************************/
int EXPORT_CC
libxrdp_orders_dest_blt(struct xrdp_session* session, int x, int y,
int cx, int cy, int rop,
struct xrdp_rect* rect)
{
return xrdp_orders_dest_blt((struct xrdp_orders*)session->orders,
x, y, cx, cy, rop, rect);
}
/******************************************************************************/
int EXPORT_CC
libxrdp_orders_line(struct xrdp_session* session, int mix_mode,
int startx, int starty,
int endx, int endy, int rop, int bg_color,
struct xrdp_pen* pen,
struct xrdp_rect* rect)
{
return xrdp_orders_line((struct xrdp_orders*)session->orders,
mix_mode, startx, starty, endx, endy,
rop, bg_color, pen, rect);
}
/******************************************************************************/
int EXPORT_CC
libxrdp_orders_mem_blt(struct xrdp_session* session, int cache_id,
int color_table, int x, int y, int cx, int cy,
int rop, int srcx, int srcy,
int cache_idx, struct xrdp_rect* rect)
{
return xrdp_orders_mem_blt((struct xrdp_orders*)session->orders,
cache_id, color_table, x, y, cx, cy, rop,
srcx, srcy, cache_idx, rect);
}
/******************************************************************************/
int EXPORT_CC
libxrdp_orders_text(struct xrdp_session* session,
int font, int flags, int mixmode,
int fg_color, int bg_color,
int clip_left, int clip_top,
int clip_right, int clip_bottom,
int box_left, int box_top,
int box_right, int box_bottom,
int x, int y, char* data, int data_len,
struct xrdp_rect* rect)
{
return xrdp_orders_text((struct xrdp_orders*)session->orders,
font, flags, mixmode, fg_color, bg_color,
clip_left, clip_top, clip_right, clip_bottom,
box_left, box_top, box_right, box_bottom,
x, y, data, data_len, rect);
}
/******************************************************************************/
int EXPORT_CC
libxrdp_orders_send_palette(struct xrdp_session* session, int* palette,
int cache_id)
{
return xrdp_orders_send_palette((struct xrdp_orders*)session->orders,
palette, cache_id);
}
/*****************************************************************************/
int EXPORT_CC
libxrdp_orders_send_raw_bitmap(struct xrdp_session* session,
int width, int height, int bpp, char* data,
int cache_id, int cache_idx)
{
return xrdp_orders_send_raw_bitmap((struct xrdp_orders*)session->orders,
width, height, bpp, data,
cache_id, cache_idx);
}
/*****************************************************************************/
int EXPORT_CC
libxrdp_orders_send_bitmap(struct xrdp_session* session,
int width, int height, int bpp, char* data,
int cache_id, int cache_idx)
{
return xrdp_orders_send_bitmap((struct xrdp_orders*)session->orders,
width, height, bpp, data,
cache_id, cache_idx);
}
/*****************************************************************************/
int EXPORT_CC
libxrdp_orders_send_font(struct xrdp_session* session,
struct xrdp_font_char* font_char,
int font_index, int char_index)
{
return xrdp_orders_send_font((struct xrdp_orders*)session->orders,
font_char, font_index, char_index);
}

@ -0,0 +1,342 @@
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
xrdp: A Remote Desktop Protocol server.
Copyright (C) Jay Sorg 2004-2005
libxrdp header
*/
#if !defined(LIBXRDP_H)
#define LIBXRDP_H
#include "arch.h"
#include "parse.h"
#include "xrdp_constants.h"
#include "defines.h"
#include "os_calls.h"
#include "ssl_calls.h"
#include "list.h"
#include "file.h"
#include "libxrdpinc.h"
/* tcp */
struct xrdp_tcp
{
int sck;
int sck_closed;
struct xrdp_iso* iso_layer; /* owner */
};
/* iso */
struct xrdp_iso
{
struct xrdp_mcs* mcs_layer; /* owner */
struct xrdp_tcp* tcp_layer;
};
/* mcs */
struct xrdp_mcs
{
struct xrdp_sec* sec_layer; /* owner */
struct xrdp_iso* iso_layer;
int userid;
int chanid;
struct stream* client_mcs_data;
struct stream* server_mcs_data;
};
/* sec */
struct xrdp_sec
{
struct xrdp_rdp* rdp_layer; /* owner */
struct xrdp_mcs* mcs_layer;
char server_random[32];
char client_random[64];
char client_crypt_random[72];
struct stream client_mcs_data;
struct stream server_mcs_data;
int decrypt_use_count;
int encrypt_use_count;
char decrypt_key[16];
char encrypt_key[16];
char decrypt_update_key[16];
char encrypt_update_key[16];
int rc4_key_size;
int rc4_key_len;
char sign_key[16];
void* decrypt_rc4_info;
void* encrypt_rc4_info;
};
/* rdp */
struct xrdp_rdp
{
struct xrdp_session* session;
struct xrdp_sec* sec_layer;
int share_id;
int mcs_channel;
struct xrdp_client_info client_info;
};
/* orders */
struct xrdp_orders
{
struct stream* out_s;
struct xrdp_rdp* rdp_layer;
struct xrdp_session* session;
struct xrdp_wm* wm;
char* order_count_ptr; /* pointer to count, set when sending */
int order_count;
int order_level; /* inc for every call to xrdp_orders_init */
int last_order; /* last order sent */
int clip_left; /* RDP_ORDER_BOUNDS, RDP_ORDER_LASTBOUNDS */
int clip_top;
int clip_right;
int clip_bottom;
int rect_x; /* RDP_ORDER_RECT */
int rect_y;
int rect_cx;
int rect_cy;
int rect_color;
int scr_blt_x; /* RDP_ORDER_SCREENBLT */
int scr_blt_y;
int scr_blt_cx;
int scr_blt_cy;
int scr_blt_rop;
int scr_blt_srcx;
int scr_blt_srcy;
int pat_blt_x; /* RDP_ORDER_PATBLT */
int pat_blt_y;
int pat_blt_cx;
int pat_blt_cy;
int pat_blt_rop;
int pat_blt_bg_color;
int pat_blt_fg_color;
struct xrdp_brush pat_blt_brush;
int dest_blt_x; /* RDP_ORDER_DESTBLT */
int dest_blt_y;
int dest_blt_cx;
int dest_blt_cy;
int dest_blt_rop;
int line_mix_mode; /* RDP_ORDER_LINE */
int line_startx;
int line_starty;
int line_endx;
int line_endy;
int line_bg_color;
int line_rop;
struct xrdp_pen line_pen;
int mem_blt_color_table; /* RDP_ORDER_MEMBLT */
int mem_blt_cache_id;
int mem_blt_x;
int mem_blt_y;
int mem_blt_cx;
int mem_blt_cy;
int mem_blt_rop;
int mem_blt_srcx;
int mem_blt_srcy;
int mem_blt_cache_idx;
int text_font; /* RDP_ORDER_TEXT2 */
int text_flags;
int text_unknown;
int text_mixmode;
int text_fg_color;
int text_bg_color;
int text_clip_left;
int text_clip_top;
int text_clip_right;
int text_clip_bottom;
int text_box_left;
int text_box_top;
int text_box_right;
int text_box_bottom;
int text_x;
int text_y;
int text_len;
char* text_data;
};
/* xrdp_tcp.c */
struct xrdp_tcp* APP_CC
xrdp_tcp_create(struct xrdp_iso* owner, int sck);
void APP_CC
xrdp_tcp_delete(struct xrdp_tcp* self);
int APP_CC
xrdp_tcp_init(struct xrdp_tcp* self, struct stream* s);
int APP_CC
xrdp_tcp_recv(struct xrdp_tcp* self, struct stream* s, int len);
int APP_CC
xrdp_tcp_send(struct xrdp_tcp* self, struct stream* s);
/* xrdp_iso.c */
struct xrdp_iso* APP_CC
xrdp_iso_create(struct xrdp_mcs* owner, int sck);
void APP_CC
xrdp_iso_delete(struct xrdp_iso* self);
int APP_CC
xrdp_iso_init(struct xrdp_iso* self, struct stream* s);
int APP_CC
xrdp_iso_recv(struct xrdp_iso* self, struct stream* s);
int APP_CC
xrdp_iso_send(struct xrdp_iso* self, struct stream* s);
int APP_CC
xrdp_iso_incoming(struct xrdp_iso* self);
/* xrdp_mcs.c */
struct xrdp_mcs* APP_CC
xrdp_mcs_create(struct xrdp_sec* owner, int sck,
struct stream* client_mcs_data,
struct stream* server_mcs_data);
void APP_CC
xrdp_mcs_delete(struct xrdp_mcs* self);
int APP_CC
xrdp_mcs_init(struct xrdp_mcs* self, struct stream* s);
int APP_CC
xrdp_mcs_recv(struct xrdp_mcs* self, struct stream* s, int* chan);
int APP_CC
xrdp_mcs_send(struct xrdp_mcs* self, struct stream* s);
int APP_CC
xrdp_mcs_incoming(struct xrdp_mcs* self);
int APP_CC
xrdp_mcs_disconnect(struct xrdp_mcs* self);
/* xrdp_sec.c */
struct xrdp_sec* APP_CC
xrdp_sec_create(struct xrdp_rdp* owner, int sck);
void APP_CC
xrdp_sec_delete(struct xrdp_sec* self);
int APP_CC
xrdp_sec_init(struct xrdp_sec* self, struct stream* s);
int APP_CC
xrdp_sec_recv(struct xrdp_sec* self, struct stream* s, int* chan);
int APP_CC
xrdp_sec_send(struct xrdp_sec* self, struct stream* s, int flags);
int APP_CC
xrdp_sec_incoming(struct xrdp_sec* self);
int APP_CC
xrdp_sec_disconnect(struct xrdp_sec* self);
/* xrdp_rdp.c */
struct xrdp_rdp* APP_CC
xrdp_rdp_create(struct xrdp_session* session, int sck);
void APP_CC
xrdp_rdp_delete(struct xrdp_rdp* self);
int APP_CC
xrdp_rdp_init(struct xrdp_rdp* self, struct stream* s);
int APP_CC
xrdp_rdp_init_data(struct xrdp_rdp* self, struct stream* s);
int APP_CC
xrdp_rdp_recv(struct xrdp_rdp* self, struct stream* s, int* code);
int APP_CC
xrdp_rdp_send(struct xrdp_rdp* self, struct stream* s, int pdu_type);
int APP_CC
xrdp_rdp_send_data(struct xrdp_rdp* self, struct stream* s,
int data_pdu_type);
int APP_CC
xrdp_rdp_incoming(struct xrdp_rdp* self);
int APP_CC
xrdp_rdp_send_demand_active(struct xrdp_rdp* self);
int APP_CC
xrdp_rdp_process_confirm_active(struct xrdp_rdp* self, struct stream* s);
int APP_CC
xrdp_rdp_process_data(struct xrdp_rdp* self, struct stream* s);
int APP_CC
xrdp_rdp_disconnect(struct xrdp_rdp* self);
/* xrdp_orders.c */
struct xrdp_orders* APP_CC
xrdp_orders_create(struct xrdp_session* session,
struct xrdp_rdp* rdp_layer);
void APP_CC
xrdp_orders_delete(struct xrdp_orders* self);
int APP_CC
xrdp_orders_init(struct xrdp_orders* self);
int APP_CC
xrdp_orders_send(struct xrdp_orders* self);
int APP_CC
xrdp_orders_force_send(struct xrdp_orders* self);
int APP_CC
xrdp_orders_rect(struct xrdp_orders* self, int x, int y, int cx, int cy,
int color, struct xrdp_rect* rect);
int APP_CC
xrdp_orders_screen_blt(struct xrdp_orders* self, int x, int y,
int cx, int cy, int srcx, int srcy,
int rop, struct xrdp_rect* rect);
int APP_CC
xrdp_orders_pat_blt(struct xrdp_orders* self, int x, int y,
int cx, int cy, int rop, int bg_color,
int fg_color, struct xrdp_brush* brush,
struct xrdp_rect* rect);
int APP_CC
xrdp_orders_dest_blt(struct xrdp_orders* self, int x, int y,
int cx, int cy, int rop,
struct xrdp_rect* rect);
int APP_CC
xrdp_orders_line(struct xrdp_orders* self, int mix_mode,
int startx, int starty,
int endx, int endy, int rop, int bg_color,
struct xrdp_pen* pen,
struct xrdp_rect* rect);
int APP_CC
xrdp_orders_mem_blt(struct xrdp_orders* self, int cache_id,
int color_table, int x, int y, int cx, int cy,
int rop, int srcx, int srcy,
int cache_idx, struct xrdp_rect* rect);
int APP_CC
xrdp_orders_text(struct xrdp_orders* self,
int font, int flags, int mixmode,
int fg_color, int bg_color,
int clip_left, int clip_top,
int clip_right, int clip_bottom,
int box_left, int box_top,
int box_right, int box_bottom,
int x, int y, char* data, int data_len,
struct xrdp_rect* rect);
int APP_CC
xrdp_orders_send_palette(struct xrdp_orders* self, int* palette,
int cache_id);
int APP_CC
xrdp_orders_send_raw_bitmap(struct xrdp_orders* self,
int width, int height, int bpp, char* data,
int cache_id, int cache_idx);
int APP_CC
xrdp_orders_send_bitmap(struct xrdp_orders* self,
int width, int height, int bpp, char* data,
int cache_id, int cache_idx);
int APP_CC
xrdp_orders_send_font(struct xrdp_orders* self,
struct xrdp_font_char* font_char,
int font_index, int char_index);
/* xrdp_bitmap_compress.c */
int APP_CC
xrdp_bitmap_compress(char* in_data, int width, int height,
struct stream* s, int bpp, int byte_limit,
int start_line, struct stream* temp,
int e);
#endif

@ -0,0 +1,170 @@
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
xrdp: A Remote Desktop Protocol server.
Copyright (C) Jay Sorg 2004-2005
header file for use with libxrdp.so / xrdp.dll
*/
#if !defined(LIBXRDPINC_H)
#define LIBXRDPINC_H
struct xrdp_client_info
{
int bpp;
int width;
int height;
int cache1_entries;
int cache1_size;
int cache2_entries;
int cache2_size;
int cache3_entries;
int cache3_size;
int pointer_cache_entries;
int use_bitmap_comp;
int use_bitmap_cache;
int op1; /* use smaller bitmap header, todo */
int desktop_cache;
int use_compact_packets; /* rdp5 smaller packets */
};
struct xrdp_brush
{
int x_orgin;
int y_orgin;
int style;
char pattern[8];
};
struct xrdp_pen
{
int style;
int width;
int color;
};
struct xrdp_font_char
{
int offset;
int baseline;
int width;
int height;
int incby;
char* data;
};
struct xrdp_rect
{
int left;
int top;
int right;
int bottom;
};
struct xrdp_session
{
long id;
int sck;
int term; /* do we need this */
int (*callback)(long id, int msg, long param1, long param2, long param3,
long param4);
void* rdp;
void* orders;
struct xrdp_client_info* client_info;
int up_and_running;
};
struct xrdp_session*
libxrdp_init(long id, int sck);
int
libxrdp_exit(struct xrdp_session* session);
int
libxrdp_disconnect(struct xrdp_session* session);
int
libxrdp_process_incomming(struct xrdp_session* session);
int
libxrdp_process_data(struct xrdp_session* session);
int
libxrdp_send_palette(struct xrdp_session* session, int* palette);
int
libxrdp_send_bitmap(struct xrdp_session* session, int width, int height,
int bpp, char* data, int x, int y, int cx, int cy);
int
libxrdp_send_pointer(struct xrdp_session* session, int cache_idx,
char* data, char* mask, int x, int y);
int
libxrdp_set_pointer(struct xrdp_session* session, int cache_idx);
int
libxrdp_orders_init(struct xrdp_session* session);
int
libxrdp_orders_send(struct xrdp_session* session);
int
libxrdp_orders_force_send(struct xrdp_session* session);
int
libxrdp_orders_rect(struct xrdp_session* session, int x, int y,
int cx, int cy, int color, struct xrdp_rect* rect);
int
libxrdp_orders_screen_blt(struct xrdp_session* session, int x, int y,
int cx, int cy, int srcx, int srcy,
int rop, struct xrdp_rect* rect);
int
libxrdp_orders_pat_blt(struct xrdp_session* session, int x, int y,
int cx, int cy, int rop, int bg_color,
int fg_color, struct xrdp_brush* brush,
struct xrdp_rect* rect);
int
libxrdp_orders_dest_blt(struct xrdp_session* session, int x, int y,
int cx, int cy, int rop,
struct xrdp_rect* rect);
int
libxrdp_orders_line(struct xrdp_session* session, int mix_mode,
int startx, int starty,
int endx, int endy, int rop, int bg_color,
struct xrdp_pen* pen,
struct xrdp_rect* rect);
int
libxrdp_orders_mem_blt(struct xrdp_session* session, int cache_id,
int color_table, int x, int y, int cx, int cy,
int rop, int srcx, int srcy,
int cache_idx, struct xrdp_rect* rect);
int
libxrdp_orders_text(struct xrdp_session* session,
int font, int flags, int mixmode,
int fg_color, int bg_color,
int clip_left, int clip_top,
int clip_right, int clip_bottom,
int box_left, int box_top,
int box_right, int box_bottom,
int x, int y, char* data, int data_len,
struct xrdp_rect* rect);
int
libxrdp_orders_send_palette(struct xrdp_session* session, int* palette,
int cache_id);
int
libxrdp_orders_send_raw_bitmap(struct xrdp_session* session,
int width, int height, int bpp, char* data,
int cache_id, int cache_idx);
int
libxrdp_orders_send_bitmap(struct xrdp_session* session,
int width, int height, int bpp, char* data,
int cache_id, int cache_idx);
int
libxrdp_orders_send_font(struct xrdp_session* session,
struct xrdp_font_char* font_char,
int font_index, int char_index);
#endif

@ -0,0 +1,42 @@
# borland windows makefile
#
# this assumes openssl and borland free command line tools are installed
# this assumes c:\windows is windows directory
#
# run 'set PATH=c:\borland\bcc55\bin' and run 'make -f makefile_win32 all'
#
XRDPOBJ = libxrdp.obj xrdp_tcp.obj xrdp_iso.obj xrdp_mcs.obj \
xrdp_sec.obj xrdp_rdp.obj xrdp_orders.obj \
xrdp_bitmap_compress.obj \
list.obj \
file.obj \
os_calls.obj \
ssl_calls.obj
CFLAGS = -w- -O2 -I../common -Ic:/borland/bcc55/include -Ic:/openssl/include
LDFLAGS = -Lc:/borland/bcc55/lib
xrdp: $(XRDPOBJ)
$(CC) $(LDFLAGS) -WD -exrdp.dll libeay32.lib $(XRDPOBJ)
all: lib xrdp
clean:
del $(XRDPOBJ) xrdp.dll
lib:
implib -a -w libeay32.lib c:/windows/system32/libeay32.dll
list.obj:
$(CC) $(CFLAGS) -c ../common/list.c
file.obj:
$(CC) $(CFLAGS) -c ../common/file.c
os_calls.obj:
$(CC) $(CFLAGS) -c ../common/os_calls.c
ssl_calls.obj:
$(CC) $(CFLAGS) -c ../common/ssl_calls.c

File diff suppressed because it is too large Load Diff

@ -0,0 +1,195 @@
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
xrdp: A Remote Desktop Protocol server.
Copyright (C) Jay Sorg 2004-2005
iso layer
*/
#include "libxrdp.h"
/*****************************************************************************/
struct xrdp_iso* APP_CC
xrdp_iso_create(struct xrdp_mcs* owner, int sck)
{
struct xrdp_iso* self;
self = (struct xrdp_iso*)g_malloc(sizeof(struct xrdp_iso), 1);
self->mcs_layer = owner;
self->tcp_layer = xrdp_tcp_create(self, sck);
return self;
}
/*****************************************************************************/
void APP_CC
xrdp_iso_delete(struct xrdp_iso* self)
{
if (self == 0)
{
return;
}
xrdp_tcp_delete(self->tcp_layer);
g_free(self);
}
/*****************************************************************************/
/* returns error */
static int APP_CC
xrdp_iso_recv_msg(struct xrdp_iso* self, struct stream* s, int* code)
{
int ver;
int len;
*code = 0;
if (xrdp_tcp_recv(self->tcp_layer, s, 4) != 0)
{
return 1;
}
in_uint8(s, ver);
if (ver != 3)
{
return 1;
}
in_uint8s(s, 1);
in_uint16_be(s, len);
if (xrdp_tcp_recv(self->tcp_layer, s, len - 4) != 0)
{
return 1;
}
in_uint8s(s, 1);
in_uint8(s, *code);
if (*code == ISO_PDU_DT)
{
in_uint8s(s, 1);
}
else
{
in_uint8s(s, 5);
}
return 0;
}
/*****************************************************************************/
/* returns error */
int APP_CC
xrdp_iso_recv(struct xrdp_iso* self, struct stream* s)
{
int code;
DEBUG((" in xrdp_iso_recv\n\r"));
if (xrdp_iso_recv_msg(self, s, &code) != 0)
{
DEBUG((" out xrdp_iso_recv xrdp_iso_recv_msg return non zero\n\r"));
return 1;
}
if (code != ISO_PDU_DT)
{
DEBUG((" out xrdp_iso_recv code != ISO_PDU_DT\n\r"));
return 1;
}
DEBUG((" out xrdp_iso_recv\n\r"));
return 0;
}
/*****************************************************************************/
static int APP_CC
xrdp_iso_send_msg(struct xrdp_iso* self, struct stream* s, int code)
{
if (xrdp_tcp_init(self->tcp_layer, s) != 0)
{
return 1;
}
out_uint8(s, 3);
out_uint8(s, 0);
out_uint16_be(s, 11); /* length */
out_uint8(s, 8);
out_uint8(s, code);
out_uint16_le(s, 0);
out_uint16_le(s, 0);
out_uint8(s, 0);
s_mark_end(s);
if (xrdp_tcp_send(self->tcp_layer, s) != 0)
{
return 1;
}
return 0;
}
/*****************************************************************************/
/* returns error */
int APP_CC
xrdp_iso_incoming(struct xrdp_iso* self)
{
int code;
struct stream* s;
make_stream(s);
init_stream(s, 8192);
DEBUG((" in xrdp_iso_incoming\n\r"));
if (xrdp_iso_recv_msg(self, s, &code) != 0)
{
free_stream(s);
return 1;
}
if (code != ISO_PDU_CR)
{
free_stream(s);
return 1;
}
if (xrdp_iso_send_msg(self, s, ISO_PDU_CC) != 0)
{
free_stream(s);
return 1;
}
DEBUG((" out xrdp_iso_incoming\n\r"));
free_stream(s);
return 0;
}
/*****************************************************************************/
/* returns error */
int APP_CC
xrdp_iso_init(struct xrdp_iso* self, struct stream* s)
{
xrdp_tcp_init(self->tcp_layer, s);
s_push_layer(s, iso_hdr, 7);
return 0;
}
/*****************************************************************************/
/* returns error */
int APP_CC
xrdp_iso_send(struct xrdp_iso* self, struct stream* s)
{
int len;
DEBUG((" in xrdp_iso_send\n\r"));
s_pop_layer(s, iso_hdr);
len = s->end - s->p;
out_uint8(s, 3);
out_uint8(s, 0);
out_uint16_be(s, len);
out_uint8(s, 2);
out_uint8(s, ISO_PDU_DT);
out_uint8(s, 0x80);
if (xrdp_tcp_send(self->tcp_layer, s) != 0)
{
return 1;
}
DEBUG((" out xrdp_iso_send\n\r"));
return 0;
}

@ -0,0 +1,629 @@
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
xrdp: A Remote Desktop Protocol server.
Copyright (C) Jay Sorg 2004-2005
mcs layer
*/
#include "libxrdp.h"
/*****************************************************************************/
struct xrdp_mcs* APP_CC
xrdp_mcs_create(struct xrdp_sec* owner, int sck,
struct stream* client_mcs_data,
struct stream* server_mcs_data)
{
struct xrdp_mcs* self;
self = (struct xrdp_mcs*)g_malloc(sizeof(struct xrdp_mcs), 1);
self->sec_layer = owner;
self->userid = 1;
self->chanid = 1001;
self->client_mcs_data = client_mcs_data;
self->server_mcs_data = server_mcs_data;
self->iso_layer = xrdp_iso_create(self, sck);
return self;
}
/*****************************************************************************/
void APP_CC
xrdp_mcs_delete(struct xrdp_mcs* self)
{
if (self == 0)
{
return;
}
xrdp_iso_delete(self->iso_layer);
g_free(self);
}
/*****************************************************************************/
/* returns error */
static int APP_CC
xrdp_mcs_send_cjcf(struct xrdp_mcs* self, int chanid)
{
struct stream* s;
make_stream(s);
init_stream(s, 8192);
if (xrdp_iso_init(self->iso_layer, s) != 0)
{
free_stream(s);
return 1;
}
out_uint8(s, (MCS_CJCF << 2) | 2);
out_uint8(s, 0);
out_uint16_be(s, self->userid);
out_uint16_be(s, chanid);
out_uint16_be(s, chanid);
s_mark_end(s);
if (xrdp_iso_send(self->iso_layer, s) != 0)
{
free_stream(s);
return 1;
}
free_stream(s);
return 0;
}
/*****************************************************************************/
/* returns error */
int APP_CC
xrdp_mcs_recv(struct xrdp_mcs* self, struct stream* s, int* chan)
{
int appid;
int opcode;
int len;
DEBUG((" in xrdp_mcs_recv\n\r"));
while (1)
{
if (xrdp_iso_recv(self->iso_layer, s) != 0)
{
DEBUG((" out xrdp_mcs_recv xrdp_iso_recv returned non zero\n\r"));
return 1;
}
in_uint8(s, opcode);
appid = opcode >> 2;
if (appid == MCS_DPUM)
{
DEBUG((" out xrdp_mcs_recv appid != MCS_DPUM\n\r"));
return 1;
}
if (appid == MCS_CJRQ)
{
xrdp_mcs_send_cjcf(self, self->userid + MCS_USERCHANNEL_BASE);
continue;
}
break;
}
if (appid != MCS_SDRQ)
{
DEBUG((" out xrdp_mcs_recv err got 0x%x need MCS_SDRQ\n\r", appid));
return 1;
}
in_uint8s(s, 2);
in_uint16_be(s, *chan);
in_uint8s(s, 1);
in_uint8(s, len);
if (len & 0x80)
{
in_uint8s(s, 1);
}
DEBUG((" out xrdp_mcs_recv\n\r"));
return 0;
}
/*****************************************************************************/
/* returns error */
static int APP_CC
xrdp_mcs_ber_parse_header(struct xrdp_mcs* self, struct stream* s,
int tag_val, int* len)
{
int tag;
int l;
int i;
if (tag_val > 0xff)
{
in_uint16_be(s, tag);
}
else
{
in_uint8(s, tag);
}
if (tag != tag_val)
{
return 1;
}
in_uint8(s, l);
if (l & 0x80)
{
l = l & ~0x80;
*len = 0;
while (l > 0)
{
in_uint8(s, i);
*len = (*len << 8) | i;
l--;
}
}
else
{
*len = l;
}
if (s_check(s))
{
return 0;
}
else
{
return 1;
}
}
/*****************************************************************************/
/* returns error */
static int APP_CC
xrdp_mcs_parse_domain_params(struct xrdp_mcs* self, struct stream* s)
{
int len;
if (xrdp_mcs_ber_parse_header(self, s, MCS_TAG_DOMAIN_PARAMS, &len) != 0)
{
return 1;
}
in_uint8s(s, len);
if (s_check(s))
{
return 0;
}
else
{
return 1;
}
}
/*****************************************************************************/
/* returns error */
static int APP_CC
xrdp_mcs_recv_connect_initial(struct xrdp_mcs* self)
{
int len;
struct stream* s;
make_stream(s);
init_stream(s, 8192);
if (xrdp_iso_recv(self->iso_layer, s) != 0)
{
free_stream(s);
return 1;
}
if (xrdp_mcs_ber_parse_header(self, s, MCS_CONNECT_INITIAL, &len) != 0)
{
free_stream(s);
return 1;
}
if (xrdp_mcs_ber_parse_header(self, s, BER_TAG_OCTET_STRING, &len) != 0)
{
free_stream(s);
return 1;
}
in_uint8s(s, len);
if (xrdp_mcs_ber_parse_header(self, s, BER_TAG_OCTET_STRING, &len) != 0)
{
free_stream(s);
return 1;
}
in_uint8s(s, len);
if (xrdp_mcs_ber_parse_header(self, s, BER_TAG_BOOLEAN, &len) != 0)
{
free_stream(s);
return 1;
}
in_uint8s(s, len);
if (xrdp_mcs_parse_domain_params(self, s) != 0)
{
free_stream(s);
return 1;
}
if (xrdp_mcs_parse_domain_params(self, s) != 0)
{
free_stream(s);
return 1;
}
if (xrdp_mcs_parse_domain_params(self, s) != 0)
{
free_stream(s);
return 1;
}
if (xrdp_mcs_ber_parse_header(self, s, BER_TAG_OCTET_STRING, &len) != 0)
{
free_stream(s);
return 1;
}
/* make a copy of client mcs data */
init_stream(self->client_mcs_data, len);
out_uint8a(self->client_mcs_data, s->p, len);
in_uint8s(s, len);
s_mark_end(self->client_mcs_data);
if (s_check_end(s))
{
free_stream(s);
return 0;
}
else
{
free_stream(s);
return 1;
}
}
/*****************************************************************************/
/* returns error */
static int APP_CC
xrdp_mcs_recv_edrq(struct xrdp_mcs* self)
{
int opcode;
struct stream* s;
make_stream(s);
init_stream(s, 8192);
if (xrdp_iso_recv(self->iso_layer, s) != 0)
{
free_stream(s);
return 1;
}
in_uint8(s, opcode);
if ((opcode >> 2) != MCS_EDRQ)
{
free_stream(s);
return 1;
}
in_uint8s(s, 2);
in_uint8s(s, 2);
if (opcode & 2)
{
in_uint16_be(s, self->userid);
}
if (!(s_check_end(s)))
{
free_stream(s);
return 1;
}
free_stream(s);
return 0;
}
/*****************************************************************************/
/* returns error */
static int APP_CC
xrdp_mcs_recv_aurq(struct xrdp_mcs* self)
{
int opcode;
struct stream* s;
make_stream(s);
init_stream(s, 8192);
if (xrdp_iso_recv(self->iso_layer, s) != 0)
{
free_stream(s);
return 1;
}
in_uint8(s, opcode);
if ((opcode >> 2) != MCS_AURQ)
{
free_stream(s);
return 1;
}
if (opcode & 2)
{
in_uint16_be(s, self->userid);
}
if (!(s_check_end(s)))
{
free_stream(s);
return 1;
}
free_stream(s);
return 0;
}
/*****************************************************************************/
/* returns error */
static int APP_CC
xrdp_mcs_send_aucf(struct xrdp_mcs* self)
{
struct stream* s;
make_stream(s);
init_stream(s, 8192);
if (xrdp_iso_init(self->iso_layer, s) != 0)
{
free_stream(s);
return 1;
}
out_uint8(s, ((MCS_AUCF << 2) | 2));
out_uint8s(s, 1);
out_uint16_be(s, self->userid);
s_mark_end(s);
if (xrdp_iso_send(self->iso_layer, s) != 0)
{
free_stream(s);
return 1;
}
free_stream(s);
return 0;
}
/*****************************************************************************/
/* returns error */
static int APP_CC
xrdp_mcs_recv_cjrq(struct xrdp_mcs* self)
{
int opcode;
struct stream* s;
make_stream(s);
init_stream(s, 8192);
if (xrdp_iso_recv(self->iso_layer, s) != 0)
{
free_stream(s);
return 1;
}
in_uint8(s, opcode);
if ((opcode >> 2) != MCS_CJRQ)
{
free_stream(s);
return 1;
}
in_uint8s(s, 4);
if (opcode & 2)
{
in_uint8s(s, 2);
}
if (!(s_check_end(s)))
{
free_stream(s);
return 1;
}
free_stream(s);
return 0;
}
/*****************************************************************************/
/* returns error */
static int APP_CC
xrdp_mcs_ber_out_header(struct xrdp_mcs* self, struct stream* s,
int tag_val, int len)
{
if (tag_val > 0xff)
{
out_uint16_be(s, tag_val);
}
else
{
out_uint8(s, tag_val);
}
if (len >= 0x80)
{
out_uint8(s, 0x82);
out_uint16_be(s, len);
}
else
{
out_uint8(s, len);
}
return 0;
}
/*****************************************************************************/
/* returns error */
static int APP_CC
xrdp_mcs_ber_out_int8(struct xrdp_mcs* self, struct stream* s, int value)
{
xrdp_mcs_ber_out_header(self, s, BER_TAG_INTEGER, 1);
out_uint8(s, value);
return 0;
}
#if 0 /* not used */
/*****************************************************************************/
/* returns error */
static int APP_CC
xrdp_mcs_ber_out_int16(struct xrdp_mcs* self, struct stream* s, int value)
{
xrdp_mcs_ber_out_header(self, s, BER_TAG_INTEGER, 2);
out_uint8(s, (value >> 8));
out_uint8(s, value);
return 0;
}
#endif
/*****************************************************************************/
/* returns error */
static int APP_CC
xrdp_mcs_ber_out_int24(struct xrdp_mcs* self, struct stream* s, int value)
{
xrdp_mcs_ber_out_header(self, s, BER_TAG_INTEGER, 3);
out_uint8(s, (value >> 16));
out_uint8(s, (value >> 8));
out_uint8(s, value);
return 0;
}
/*****************************************************************************/
/* returns error */
static int APP_CC
xrdp_mcs_out_domain_params(struct xrdp_mcs* self, struct stream* s,
int max_channels,
int max_users, int max_tokens,
int max_pdu_size)
{
xrdp_mcs_ber_out_header(self, s, MCS_TAG_DOMAIN_PARAMS, 26);
xrdp_mcs_ber_out_int8(self, s, max_channels);
xrdp_mcs_ber_out_int8(self, s, max_users);
xrdp_mcs_ber_out_int8(self, s, max_tokens);
xrdp_mcs_ber_out_int8(self, s, 1);
xrdp_mcs_ber_out_int8(self, s, 0);
xrdp_mcs_ber_out_int8(self, s, 1);
xrdp_mcs_ber_out_int24(self, s, max_pdu_size);
xrdp_mcs_ber_out_int8(self, s, 2);
return 0;
}
/*****************************************************************************/
/* returns error */
static int APP_CC
xrdp_mcs_send_connect_response(struct xrdp_mcs* self)
{
int data_len;
struct stream* s;
make_stream(s);
init_stream(s, 8192);
data_len = self->server_mcs_data->end - self->server_mcs_data->data;
xrdp_iso_init(self->iso_layer, s);
xrdp_mcs_ber_out_header(self, s, MCS_CONNECT_RESPONSE, 313);
xrdp_mcs_ber_out_header(self, s, BER_TAG_RESULT, 1);
out_uint8(s, 0);
xrdp_mcs_ber_out_header(self, s, BER_TAG_INTEGER, 1);
out_uint8(s, 0);
xrdp_mcs_out_domain_params(self, s, 2, 2, 0, 0xffff);
xrdp_mcs_ber_out_header(self, s, BER_TAG_OCTET_STRING, data_len);
/* mcs data */
out_uint8a(s, self->server_mcs_data->data, data_len);
s_mark_end(s);
if (xrdp_iso_send(self->iso_layer, s) != 0)
{
free_stream(s);
return 1;
}
free_stream(s);
return 0;
}
/*****************************************************************************/
/* returns error */
int APP_CC
xrdp_mcs_incoming(struct xrdp_mcs* self)
{
DEBUG((" in xrdp_mcs_incoming\n\r"));
if (xrdp_iso_incoming(self->iso_layer) != 0)
{
return 1;
}
if (xrdp_mcs_recv_connect_initial(self) != 0)
{
return 1;
}
if (xrdp_mcs_send_connect_response(self) != 0)
{
return 1;
}
if (xrdp_mcs_recv_edrq(self) != 0)
{
return 1;
}
if (xrdp_mcs_recv_aurq(self) != 0)
{
return 1;
}
if (xrdp_mcs_send_aucf(self) != 0)
{
return 1;
}
if (xrdp_mcs_recv_cjrq(self) != 0)
{
return 1;
}
if (xrdp_mcs_send_cjcf(self, self->userid + MCS_USERCHANNEL_BASE) != 0)
{
return 1;
}
if (xrdp_mcs_recv_cjrq(self) != 0)
{
return 1;
}
if (xrdp_mcs_send_cjcf(self, MCS_GLOBAL_CHANNEL) != 0)
{
return 1;
}
DEBUG((" out xrdp_mcs_incoming\n\r"));
return 0;
}
/*****************************************************************************/
/* returns error */
int APP_CC
xrdp_mcs_init(struct xrdp_mcs* self, struct stream* s)
{
xrdp_iso_init(self->iso_layer, s);
s_push_layer(s, mcs_hdr, 8);
return 0;
}
/*****************************************************************************/
/* returns error */
int APP_CC
xrdp_mcs_send(struct xrdp_mcs* self, struct stream* s)
{
int len;
DEBUG((" in xrdp_mcs_send\n\r"));
s_pop_layer(s, mcs_hdr);
len = (s->end - s->p) - 8;
len = len | 0x8000;
out_uint8(s, MCS_SDIN << 2);
out_uint16_be(s, self->userid);
out_uint16_be(s, MCS_GLOBAL_CHANNEL);
out_uint8(s, 0x70);
out_uint16_be(s, len);
if (xrdp_iso_send(self->iso_layer, s) != 0)
{
return 1;
}
DEBUG((" out xrdp_mcs_send\n\r"));
return 0;
}
/*****************************************************************************/
/* returns error */
int APP_CC
xrdp_mcs_disconnect(struct xrdp_mcs* self)
{
struct stream* s;
make_stream(s);
init_stream(s, 8192);
if (xrdp_iso_init(self->iso_layer, s) != 0)
{
free_stream(s);
return 1;
}
out_uint8(s, (MCS_DPUM << 2) | 1);
out_uint8(s, 0x80);
s_mark_end(s);
if (xrdp_iso_send(self->iso_layer, s) != 0)
{
free_stream(s);
return 1;
}
free_stream(s);
return 0;
}

File diff suppressed because it is too large Load Diff

@ -0,0 +1,847 @@
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
xrdp: A Remote Desktop Protocol server.
Copyright (C) Jay Sorg 2004-2005
rdp layer
*/
#include "libxrdp.h"
static char unknown1[172] =
{ 0xff, 0x02, 0xb6, 0x00, 0x28, 0x00, 0x00, 0x00,
0x27, 0x00, 0x27, 0x00, 0x03, 0x00, 0x04, 0x00,
0x00, 0x00, 0x26, 0x00, 0x01, 0x00, 0x1e, 0x00,
0x02, 0x00, 0x1f, 0x00, 0x03, 0x00, 0x1d, 0x00,
0x04, 0x00, 0x27, 0x00, 0x05, 0x00, 0x0b, 0x00,
0x06, 0x00, 0x28, 0x00, 0x08, 0x00, 0x21, 0x00,
0x09, 0x00, 0x20, 0x00, 0x0a, 0x00, 0x22, 0x00,
0x0b, 0x00, 0x25, 0x00, 0x0c, 0x00, 0x24, 0x00,
0x0d, 0x00, 0x23, 0x00, 0x0e, 0x00, 0x19, 0x00,
0x0f, 0x00, 0x16, 0x00, 0x10, 0x00, 0x15, 0x00,
0x11, 0x00, 0x1c, 0x00, 0x12, 0x00, 0x1b, 0x00,
0x13, 0x00, 0x1a, 0x00, 0x14, 0x00, 0x17, 0x00,
0x15, 0x00, 0x18, 0x00, 0x16, 0x00, 0x0e, 0x00,
0x18, 0x00, 0x0c, 0x00, 0x19, 0x00, 0x0d, 0x00,
0x1a, 0x00, 0x12, 0x00, 0x1b, 0x00, 0x14, 0x00,
0x1f, 0x00, 0x13, 0x00, 0x20, 0x00, 0x00, 0x00,
0x21, 0x00, 0x0a, 0x00, 0x22, 0x00, 0x06, 0x00,
0x23, 0x00, 0x07, 0x00, 0x24, 0x00, 0x08, 0x00,
0x25, 0x00, 0x09, 0x00, 0x26, 0x00, 0x04, 0x00,
0x27, 0x00, 0x03, 0x00, 0x28, 0x00, 0x02, 0x00,
0x29, 0x00, 0x01, 0x00, 0x2a, 0x00, 0x05, 0x00,
0x2b, 0x00, 0x2a, 0x00 };
/*****************************************************************************/
static int APP_CC
xrdp_rdp_read_config(struct xrdp_client_info* client_info)
{
int fd;
int index;
struct list* items;
struct list* values;
char* item;
char* value;
fd = g_file_open("xrdp.ini");
if (fd > 0)
{
items = list_create();
items->auto_free = 1;
values = list_create();
values->auto_free = 1;
file_read_section(fd, "globals", items, values);
for (index = 0; index < items->count; index++)
{
item = (char*)list_get_item(items, index);
value = (char*)list_get_item(values, index);
if (g_strcmp(item, "bitmap_cache") == 0)
{
if (g_strcmp(value, "yes") == 0)
{
client_info->use_bitmap_cache = 1;
}
}
else if (g_strcmp(item, "bitmap_compression") == 0)
{
if (g_strcmp(value, "yes") == 0)
{
client_info->use_bitmap_comp = 1;
}
}
}
list_delete(items);
list_delete(values);
g_file_close(fd);
}
return 0;
}
/*****************************************************************************/
struct xrdp_rdp* APP_CC
xrdp_rdp_create(struct xrdp_session* session, int sck)
{
struct xrdp_rdp* self;
self = (struct xrdp_rdp*)g_malloc(sizeof(struct xrdp_rdp), 1);
self->session = session;
self->share_id = 66538;
self->sec_layer = xrdp_sec_create(self, sck);
/* read ini settings */
xrdp_rdp_read_config(&self->client_info);
return self;
}
/*****************************************************************************/
void APP_CC
xrdp_rdp_delete(struct xrdp_rdp* self)
{
if (self == 0)
{
return;
}
xrdp_sec_delete(self->sec_layer);
g_free(self);
}
/*****************************************************************************/
int APP_CC
xrdp_rdp_init(struct xrdp_rdp* self, struct stream* s)
{
if (xrdp_sec_init(self->sec_layer, s) != 0)
{
return 1;
}
s_push_layer(s, rdp_hdr, 6);
return 0;
}
/*****************************************************************************/
int APP_CC
xrdp_rdp_init_data(struct xrdp_rdp* self, struct stream* s)
{
if (xrdp_sec_init(self->sec_layer, s) != 0)
{
return 1;
}
s_push_layer(s, rdp_hdr, 18);
return 0;
}
/*****************************************************************************/
/* returns erros */
int APP_CC
xrdp_rdp_recv(struct xrdp_rdp* self, struct stream* s, int* code)
{
int error;
int len;
int pdu_code;
int chan;
DEBUG(("in xrdp_rdp_recv\n\r"));
if (s->next_packet == 0 || s->next_packet >= s->end)
{
chan = 0;
error = xrdp_sec_recv(self->sec_layer, s, &chan);
if (error == -1) /* special code for send demand active */
{
s->next_packet = 0;
*code = -1;
DEBUG(("out xrdp_rdp_recv\n\r"));
return 0;
}
if (error != 0)
{
DEBUG(("out xrdp_rdp_recv error\n\r"));
return 1;
}
if (chan != MCS_GLOBAL_CHANNEL && chan > 0)
{
s->next_packet = 0;
*code = 0;
DEBUG(("out xrdp_rdp_recv\n\r"));
return 0;
}
s->next_packet = s->p;
}
else
{
s->p = s->next_packet;
}
in_uint16_le(s, len);
if (len == 0x8000)
{
s->next_packet += 8;
*code = 0;
DEBUG(("out xrdp_rdp_recv\n\r"));
return 0;
}
in_uint16_le(s, pdu_code);
*code = pdu_code & 0xf;
in_uint8s(s, 2); /* mcs user id */
s->next_packet += len;
DEBUG(("out xrdp_rdp_recv\n\r"));
return 0;
}
/*****************************************************************************/
int APP_CC
xrdp_rdp_send(struct xrdp_rdp* self, struct stream* s, int pdu_type)
{
int len;
DEBUG(("in xrdp_rdp_send\n\r"));
s_pop_layer(s, rdp_hdr);
len = s->end - s->p;
out_uint16_le(s, len);
out_uint16_le(s, 0x10 | pdu_type);
out_uint16_le(s, self->mcs_channel);
if (xrdp_sec_send(self->sec_layer, s, 0) != 0)
{
DEBUG(("out xrdp_rdp_send error\n\r"));
return 1;
}
DEBUG(("out xrdp_rdp_send\n\r"));
return 0;
}
/*****************************************************************************/
int APP_CC
xrdp_rdp_send_data(struct xrdp_rdp* self, struct stream* s,
int data_pdu_type)
{
int len;
DEBUG(("in xrdp_rdp_send_data\n\r"));
s_pop_layer(s, rdp_hdr);
len = s->end - s->p;
out_uint16_le(s, len);
out_uint16_le(s, 0x10 | RDP_PDU_DATA);
out_uint16_le(s, self->mcs_channel);
out_uint32_le(s, self->share_id);
out_uint8(s, 0);
out_uint8(s, 1);
out_uint16_le(s, len - 14);
out_uint8(s, data_pdu_type);
out_uint8(s, 0);
out_uint16_le(s, 0);
if (xrdp_sec_send(self->sec_layer, s, 0) != 0)
{
DEBUG(("out xrdp_rdp_send_data error\n\r"));
return 1;
}
DEBUG(("out xrdp_rdp_send_data\n\r"));
return 0;
}
/*****************************************************************************/
static int APP_CC
xrdp_rdp_parse_client_mcs_data(struct xrdp_rdp* self)
{
struct stream* p;
int i;
p = &self->sec_layer->client_mcs_data;
p->p = p->data;
in_uint8s(p, 31);
in_uint16_le(p, self->client_info.width);
in_uint16_le(p, self->client_info.height);
in_uint8s(p, 120);
self->client_info.bpp = 8;
in_uint16_le(p, i);
switch (i)
{
case 0xca01:
in_uint8s(p, 6);
in_uint8(p, i);
if (i > 8)
{
self->client_info.bpp = i;
}
break;
case 0xca02:
self->client_info.bpp = 15;
break;
case 0xca03:
self->client_info.bpp = 16;
break;
case 0xca04:
self->client_info.bpp = 24;
break;
}
p->p = p->data;
DEBUG(("client width %d, client height %d bpp %d\n\r",
self->client_info.width, self->client_info.height,
self->client_info.bpp));
return 0;
}
/*****************************************************************************/
int APP_CC
xrdp_rdp_incoming(struct xrdp_rdp* self)
{
DEBUG(("in xrdp_rdp_incoming\n\r"));
if (xrdp_sec_incoming(self->sec_layer) != 0)
{
return 1;
}
self->mcs_channel = self->sec_layer->mcs_layer->userid +
MCS_USERCHANNEL_BASE;
xrdp_rdp_parse_client_mcs_data(self);
DEBUG(("out xrdp_rdp_incoming mcs channel %d\n\r", self->mcs_channel));
return 0;
}
/*****************************************************************************/
int APP_CC
xrdp_rdp_send_demand_active(struct xrdp_rdp* self)
{
struct stream* s;
make_stream(s);
init_stream(s, 8192);
if (xrdp_rdp_init(self, s) != 0)
{
free_stream(s);
return 1;
}
out_uint32_le(s, self->share_id);
out_uint32_be(s, 0x04000401);
out_uint32_be(s, 0x524e5300);
out_uint32_be(s, 0x08000000);
out_uint32_be(s, 0x09000800);
out_uint16_le(s, self->mcs_channel);
out_uint16_be(s, 0xb5e2);
/* Output general capability set */
out_uint16_le(s, RDP_CAPSET_GENERAL); /* 1 */
out_uint16_le(s, RDP_CAPLEN_GENERAL); /* 24(0x18) */
out_uint16_le(s, 1); /* OS major type */
out_uint16_le(s, 3); /* OS minor type */
out_uint16_le(s, 0x200); /* Protocol version */
out_uint16_le(s, 0); /* pad */
out_uint16_le(s, 0); /* Compression types */
out_uint16_le(s, 0); /* pad */
out_uint16_le(s, 0); /* Update capability */
out_uint16_le(s, 0); /* Remote unshare capability */
out_uint16_le(s, 0); /* Compression level */
out_uint16_le(s, 0); /* Pad */
/* Output bitmap capability set */
out_uint16_le(s, RDP_CAPSET_BITMAP); /* 2 */
out_uint16_le(s, RDP_CAPLEN_BITMAP); /* 28(0x1c) */
out_uint16_le(s, self->client_info.bpp); /* Preferred BPP */
out_uint16_le(s, 1); /* Receive 1 BPP */
out_uint16_le(s, 1); /* Receive 4 BPP */
out_uint16_le(s, 1); /* Receive 8 BPP */
out_uint16_le(s, self->client_info.width); /* width */
out_uint16_le(s, self->client_info.height); /* height */
out_uint16_le(s, 0); /* Pad */
out_uint16_le(s, 1); /* Allow resize */
out_uint16_le(s, 1); /* bitmap compression */
out_uint16_le(s, 0); /* unknown */
out_uint16_le(s, 0); /* unknown */
out_uint16_le(s, 0); /* pad */
/* Output ? */
out_uint16_le(s, 14);
out_uint16_le(s, 4);
/* Output order capability set */
out_uint16_le(s, RDP_CAPSET_ORDER); /* 3 */
out_uint16_le(s, RDP_CAPLEN_ORDER); /* 88(0x58) */
out_uint8s(s, 16);
out_uint32_be(s, 0x40420f00);
out_uint16_le(s, 1); /* Cache X granularity */
out_uint16_le(s, 20); /* Cache Y granularity */
out_uint16_le(s, 0); /* Pad */
out_uint16_le(s, 1); /* Max order level */
out_uint16_le(s, 0x2f); /* Number of fonts */
out_uint16_le(s, 0x22); /* Capability flags */
/* caps */
out_uint8(s, 1); /* dest blt */
out_uint8(s, 1); /* pat blt */
out_uint8(s, 1); /* screen blt */
out_uint8(s, 1); /* memblt */
out_uint8(s, 1);
out_uint8(s, 1);
out_uint8(s, 1);
out_uint8(s, 1);
out_uint8(s, 1);
out_uint8(s, 1);
out_uint8(s, 1);
out_uint8(s, 1);
out_uint8(s, 1);
out_uint8(s, 0);
out_uint8(s, 0);
out_uint8(s, 1);
out_uint8(s, 1);
out_uint8(s, 1);
out_uint8(s, 1);
out_uint8(s, 1);
out_uint8(s, 1);
out_uint8(s, 1);
out_uint8(s, 1);
out_uint8(s, 1);
out_uint8(s, 1);
out_uint8(s, 1);
out_uint8(s, 1);
out_uint8(s, 1);
out_uint8(s, 1);
out_uint8(s, 0);
out_uint8(s, 0);
out_uint8(s, 0);
out_uint16_le(s, 0x6a1);
out_uint8s(s, 6); /* ? */
out_uint32_le(s, 0x0f4240); /* desk save */
out_uint32_le(s, 0); /* ? */
out_uint32_le(s, 0); /* ? */
/* Output color cache capability set */
out_uint16_le(s, RDP_CAPSET_COLCACHE);
out_uint16_le(s, RDP_CAPLEN_COLCACHE);
out_uint16_le(s, 6); /* cache size */
out_uint16_le(s, 0); /* pad */
/* Output pointer capability set */
out_uint16_le(s, RDP_CAPSET_POINTER);
out_uint16_le(s, RDP_CAPLEN_POINTER);
out_uint16_le(s, 1); /* Colour pointer */
out_uint16_le(s, 0x19); /* Cache size */
/* Output ? */
out_uint16_le(s, 0xd);
out_uint16_le(s, 0x58); /* 88 */
out_uint8(s, 1);
out_uint8s(s, 83);
s_mark_end(s);
if (xrdp_rdp_send(self, s, RDP_PDU_DEMAND_ACTIVE) != 0)
{
free_stream(s);
return 1;
}
free_stream(s);
return 0;
}
/*****************************************************************************/
static int APP_CC
xrdp_process_capset_general(struct xrdp_rdp* self, struct stream* s,
int len)
{
int i;
in_uint8s(s, 10);
in_uint16_le(s, i);
self->client_info.use_compact_packets = (i != 0);
return 0;
}
/*****************************************************************************/
static int APP_CC
xrdp_process_capset_order(struct xrdp_rdp* self, struct stream* s,
int len)
{
int i;
in_uint8s(s, 72);
in_uint32_le(s, i); /* desktop cache size, usually 0x38400 */
self->client_info.desktop_cache = i;
return 0;
}
/*****************************************************************************/
/* get the bitmap cache size */
static int APP_CC
xrdp_process_capset_bmpcache(struct xrdp_rdp* self, struct stream* s,
int len)
{
in_uint8s(s, 24);
in_uint16_le(s, self->client_info.cache1_entries);
in_uint16_le(s, self->client_info.cache1_size);
in_uint16_le(s, self->client_info.cache2_entries);
in_uint16_le(s, self->client_info.cache2_size);
in_uint16_le(s, self->client_info.cache3_entries);
in_uint16_le(s, self->client_info.cache3_size);
return 0;
}
/*****************************************************************************/
/* get the number of client cursor cache */
static int APP_CC
xrdp_process_capset_pointercache(struct xrdp_rdp* self, struct stream* s,
int len)
{
int i;
in_uint8s(s, 2); /* color pointer */
in_uint16_le(s, i);
i = MIN(i, 32);
self->client_info.pointer_cache_entries = i;
return 0;
}
/*****************************************************************************/
int APP_CC
xrdp_rdp_process_confirm_active(struct xrdp_rdp* self, struct stream* s)
{
int cap_len;
int source_len;
int num_caps;
int index;
int type;
int len;
char* p;
in_uint8s(s, 4); /* rdp_shareid */
in_uint8s(s, 2); /* userid */
in_uint16_le(s, source_len); /* sizeof RDP_SOURCE */
in_uint16_le(s, cap_len);
in_uint8s(s, source_len);
in_uint16_le(s, num_caps);
in_uint8s(s, 2); /* pad */
for (index = 0; index < num_caps; index++)
{
p = s->p;
in_uint16_le(s, type);
in_uint16_le(s, len);
switch (type)
{
case RDP_CAPSET_GENERAL: /* 1 */
xrdp_process_capset_general(self, s, len);
break;
case RDP_CAPSET_ORDER: /* 3 */
xrdp_process_capset_order(self, s, len);
break;
case RDP_CAPSET_BMPCACHE: /* 4 */
xrdp_process_capset_bmpcache(self, s, len);
break;
case RDP_CAPSET_POINTER: /* 8 */
xrdp_process_capset_pointercache(self, s, len);
break;
}
s->p = p + len;
}
return 0;
}
/*****************************************************************************/
static int APP_CC
xrdp_rdp_process_data_pointer(struct xrdp_rdp* self, struct stream* s)
{
return 0;
}
/*****************************************************************************/
/* RDP_DATA_PDU_INPUT */
static int APP_CC
xrdp_rdp_process_data_input(struct xrdp_rdp* self, struct stream* s)
{
int num_events;
int index;
int msg_type;
int device_flags;
int param1;
int param2;
int time;
in_uint16_le(s, num_events);
in_uint8s(s, 2); /* pad */
DEBUG(("xrdp_rdp_process_data_input %d events\n\r", num_events));
for (index = 0; index < num_events; index++)
{
in_uint32_le(s, time);
in_uint16_le(s, msg_type);
in_uint16_le(s, device_flags);
in_sint16_le(s, param1);
in_sint16_le(s, param2);
DEBUG(("xrdp_rdp_process_data_input event %4.4x flags %4.4x param1 %d \
param2 %d time %d\n\r", msg_type, device_flags, param1, param2, time));
if (self->session->callback != 0)
{
/* msg_type can be
RDP_INPUT_SYNCHRONIZE - 0
RDP_INPUT_SCANCODE - 4
RDP_INPUT_MOUSE - 0x8001 */
self->session->callback(self->session->id, msg_type, param1, param2,
device_flags, time);
}
}
return 0;
}
/*****************************************************************************/
static int APP_CC
xrdp_rdp_send_synchronise(struct xrdp_rdp* self)
{
struct stream* s;
make_stream(s);
init_stream(s, 8192);
if (xrdp_rdp_init_data(self, s) != 0)
{
free_stream(s);
return 1;
}
out_uint16_le(s, 1);
out_uint16_le(s, 1002);
s_mark_end(s);
if (xrdp_rdp_send_data(self, s, RDP_DATA_PDU_SYNCHRONISE) != 0)
{
free_stream(s);
return 1;
}
free_stream(s);
return 0;
}
/*****************************************************************************/
static int APP_CC
xrdp_rdp_send_control(struct xrdp_rdp* self, int action)
{
struct stream* s;
make_stream(s);
init_stream(s, 8192);
if (xrdp_rdp_init_data(self, s) != 0)
{
free_stream(s);
return 1;
}
out_uint16_le(s, action);
out_uint16_le(s, 0); /* userid */
out_uint32_le(s, 1002); /* control id */
s_mark_end(s);
if (xrdp_rdp_send_data(self, s, RDP_DATA_PDU_CONTROL) != 0)
{
free_stream(s);
return 1;
}
free_stream(s);
return 0;
}
/*****************************************************************************/
static int APP_CC
xrdp_rdp_process_data_control(struct xrdp_rdp* self, struct stream* s)
{
int action;
in_uint16_le(s, action);
in_uint8s(s, 2); /* user id */
in_uint8s(s, 4); /* control id */
if (action == RDP_CTL_REQUEST_CONTROL)
{
xrdp_rdp_send_synchronise(self);
xrdp_rdp_send_control(self, RDP_CTL_COOPERATE);
xrdp_rdp_send_control(self, RDP_CTL_GRANT_CONTROL);
}
return 0;
}
/*****************************************************************************/
static int APP_CC
xrdp_rdp_process_data_sync(struct xrdp_rdp* self)
{
return 0;
}
/*****************************************************************************/
static int APP_CC
xrdp_rdp_process_screen_update(struct xrdp_rdp* self, struct stream* s)
{
int op;
int left;
int top;
int right;
int bottom;
int cx;
int cy;
in_uint32_le(s, op);
in_uint16_le(s, left);
in_uint16_le(s, top);
in_uint16_le(s, right);
in_uint16_le(s, bottom);
cx = (right - left) + 1;
cy = (bottom - top) + 1;
if (self->session->callback != 0)
{
self->session->callback(self->session->id, 0x4444, left, top, cx, cy);
}
return 0;
}
/*****************************************************************************/
static int APP_CC
xrdp_rdp_send_unknown1(struct xrdp_rdp* self)
{
struct stream* s;
make_stream(s);
init_stream(s, 8192);
if (xrdp_rdp_init_data(self, s) != 0)
{
free_stream(s);
return 1;
}
out_uint8a(s, unknown1, 172);
s_mark_end(s);
if (xrdp_rdp_send_data(self, s, 0x28) != 0)
{
free_stream(s);
return 1;
}
free_stream(s);
return 0;
}
/*****************************************************************************/
static int APP_CC
xrdp_rdp_process_data_font(struct xrdp_rdp* self, struct stream* s)
{
int seq;
in_uint8s(s, 2); /* num of fonts */
in_uint8s(s, 2); /* unknown */
in_uint16_le(s, seq);
/* 419 client sends Seq 1, then 2 */
/* 2600 clients sends only Seq 3 */
if (seq == 2 || seq == 3) /* after second font message, we are up and */
{ /* running */
xrdp_rdp_send_unknown1(self);
self->session->up_and_running = 1;
}
return 0;
}
/*****************************************************************************/
/* sent 37 pdu */
static int APP_CC
xrdp_rdp_send_disconnect_query_response(struct xrdp_rdp* self)
{
struct stream* s;
make_stream(s);
init_stream(s, 8192);
if (xrdp_rdp_init_data(self, s) != 0)
{
free_stream(s);
return 1;
}
s_mark_end(s);
if (xrdp_rdp_send_data(self, s, 37) != 0)
{
free_stream(s);
return 1;
}
free_stream(s);
return 0;
}
#if 0 /* not used */
/*****************************************************************************/
/* sent RDP_DATA_PDU_DISCONNECT 47 pdu */
static int APP_CC
xrdp_rdp_send_disconnect_reason(struct xrdp_rdp* self, int reason)
{
struct stream* s;
make_stream(s);
init_stream(s, 8192);
if (xrdp_rdp_init_data(self, s) != 0)
{
free_stream(s);
return 1;
}
out_uint32_le(s, reason);
s_mark_end(s);
if (xrdp_rdp_send_data(self, s, RDP_DATA_PDU_DISCONNECT) != 0)
{
free_stream(s);
return 1;
}
free_stream(s);
return 0;
}
#endif
/*****************************************************************************/
/* RDP_PDU_DATA */
int APP_CC
xrdp_rdp_process_data(struct xrdp_rdp* self, struct stream* s)
{
int len;
int data_type;
int ctype;
int clen;
in_uint8s(s, 6);
in_uint16_le(s, len);
in_uint8(s, data_type);
in_uint8(s, ctype);
in_uint16_le(s, clen);
DEBUG(("xrdp_rdp_process_data code %d\n\r", data_type));
switch (data_type)
{
case RDP_DATA_PDU_POINTER: /* 27 */
xrdp_rdp_process_data_pointer(self, s);
break;
case RDP_DATA_PDU_INPUT: /* 28 */
xrdp_rdp_process_data_input(self, s);
break;
case RDP_DATA_PDU_CONTROL: /* 20 */
xrdp_rdp_process_data_control(self, s);
break;
case RDP_DATA_PDU_SYNCHRONISE: /* 31 */
xrdp_rdp_process_data_sync(self);
break;
case 33: /* 33 ?? Invalidate an area I think */
xrdp_rdp_process_screen_update(self, s);
break;
case 35:
/* 35 ?? this comes when minimuzing a full screen mstsc.exe 2600 */
/* I think this is saying the client no longer wants screen */
/* updates and it will issue a 33 above to catch up */
/* so minimized apps don't take bandwidth */
break;
case 36: /* 36 ?? disconnect query? */
/* when this message comes, send a 37 back so the client */
/* is sure the connection is alive and it can ask if user */
/* really wants to disconnect */
xrdp_rdp_send_disconnect_query_response(self); /* send a 37 back */
break;
case RDP_DATA_PDU_FONT2: /* 39 */
xrdp_rdp_process_data_font(self, s);
break;
default:
g_printf("unknown in xrdp_rdp_process_data %d\n\r", data_type);
break;
}
return 0;
}
/*****************************************************************************/
int APP_CC
xrdp_rdp_disconnect(struct xrdp_rdp* self)
{
return xrdp_sec_disconnect(self->sec_layer);
}

@ -0,0 +1,606 @@
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
xrdp: A Remote Desktop Protocol server.
Copyright (C) Jay Sorg 2004-2005
secure layer
*/
#include "libxrdp.h"
static char pad_54[40] =
{ 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
54, 54, 54, 54, 54, 54, 54, 54 };
static char pad_92[48] =
{ 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92 };
static char pub_exp[4] = { 0x01, 0x00, 0x01, 0x00 };
static char pub_mod[64] =
{ 0x67, 0xab, 0x0e, 0x6a, 0x9f, 0xd6, 0x2b, 0xa3,
0x32, 0x2f, 0x41, 0xd1, 0xce, 0xee, 0x61, 0xc3,
0x76, 0x0b, 0x26, 0x11, 0x70, 0x48, 0x8a, 0x8d,
0x23, 0x81, 0x95, 0xa0, 0x39, 0xf7, 0x5b, 0xaa,
0x3e, 0xf1, 0xed, 0xb8, 0xc4, 0xee, 0xce, 0x5f,
0x6a, 0xf5, 0x43, 0xce, 0x5f, 0x60, 0xca, 0x6c,
0x06, 0x75, 0xae, 0xc0, 0xd6, 0xa4, 0x0c, 0x92,
0xa4, 0xc6, 0x75, 0xea, 0x64, 0xb2, 0x50, 0x5b };
static char pub_sig[64] =
{ 0x6a, 0x41, 0xb1, 0x43, 0xcf, 0x47, 0x6f, 0xf1,
0xe6, 0xcc, 0xa1, 0x72, 0x97, 0xd9, 0xe1, 0x85,
0x15, 0xb3, 0xc2, 0x39, 0xa0, 0xa6, 0x26, 0x1a,
0xb6, 0x49, 0x01, 0xfa, 0xa6, 0xda, 0x60, 0xd7,
0x45, 0xf7, 0x2c, 0xee, 0xe4, 0x8e, 0x64, 0x2e,
0x37, 0x49, 0xf0, 0x4c, 0x94, 0x6f, 0x08, 0xf5,
0x63, 0x4c, 0x56, 0x29, 0x55, 0x5a, 0x63, 0x41,
0x2c, 0x20, 0x65, 0x95, 0x99, 0xb1, 0x15, 0x7c };
static char pri_exp[64] =
{ 0x41, 0x93, 0x05, 0xB1, 0xF4, 0x38, 0xFC, 0x47,
0x88, 0xC4, 0x7F, 0x83, 0x8C, 0xEC, 0x90, 0xDA,
0x0C, 0x8A, 0xB5, 0xAE, 0x61, 0x32, 0x72, 0xF5,
0x2B, 0xD1, 0x7B, 0x5F, 0x44, 0xC0, 0x7C, 0xBD,
0x8A, 0x35, 0xFA, 0xAE, 0x30, 0xF6, 0xC4, 0x6B,
0x55, 0xA7, 0x65, 0xEF, 0xF4, 0xB2, 0xAB, 0x18,
0x4E, 0xAA, 0xE6, 0xDC, 0x71, 0x17, 0x3B, 0x4C,
0xC2, 0x15, 0x4C, 0xF7, 0x81, 0xBB, 0xF0, 0x03 };
static char lic1[322] =
{ 0x80, 0x00, 0x3e, 0x01, 0x01, 0x02, 0x3e, 0x01,
0x7b, 0x3c, 0x31, 0xa6, 0xae, 0xe8, 0x74, 0xf6,
0xb4, 0xa5, 0x03, 0x90, 0xe7, 0xc2, 0xc7, 0x39,
0xba, 0x53, 0x1c, 0x30, 0x54, 0x6e, 0x90, 0x05,
0xd0, 0x05, 0xce, 0x44, 0x18, 0x91, 0x83, 0x81,
0x00, 0x00, 0x04, 0x00, 0x2c, 0x00, 0x00, 0x00,
0x4d, 0x00, 0x69, 0x00, 0x63, 0x00, 0x72, 0x00,
0x6f, 0x00, 0x73, 0x00, 0x6f, 0x00, 0x66, 0x00,
0x74, 0x00, 0x20, 0x00, 0x43, 0x00, 0x6f, 0x00,
0x72, 0x00, 0x70, 0x00, 0x6f, 0x00, 0x72, 0x00,
0x61, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6f, 0x00,
0x6e, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
0x32, 0x00, 0x33, 0x00, 0x36, 0x00, 0x00, 0x00,
0x0d, 0x00, 0x04, 0x00, 0x01, 0x00, 0x00, 0x00,
0x03, 0x00, 0xb8, 0x00, 0x01, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x06, 0x00, 0x5c, 0x00, 0x52, 0x53, 0x41, 0x31,
0x48, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
0x3f, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00,
0x01, 0xc7, 0xc9, 0xf7, 0x8e, 0x5a, 0x38, 0xe4,
0x29, 0xc3, 0x00, 0x95, 0x2d, 0xdd, 0x4c, 0x3e,
0x50, 0x45, 0x0b, 0x0d, 0x9e, 0x2a, 0x5d, 0x18,
0x63, 0x64, 0xc4, 0x2c, 0xf7, 0x8f, 0x29, 0xd5,
0x3f, 0xc5, 0x35, 0x22, 0x34, 0xff, 0xad, 0x3a,
0xe6, 0xe3, 0x95, 0x06, 0xae, 0x55, 0x82, 0xe3,
0xc8, 0xc7, 0xb4, 0xa8, 0x47, 0xc8, 0x50, 0x71,
0x74, 0x29, 0x53, 0x89, 0x6d, 0x9c, 0xed, 0x70,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x08, 0x00, 0x48, 0x00, 0xa8, 0xf4, 0x31, 0xb9,
0xab, 0x4b, 0xe6, 0xb4, 0xf4, 0x39, 0x89, 0xd6,
0xb1, 0xda, 0xf6, 0x1e, 0xec, 0xb1, 0xf0, 0x54,
0x3b, 0x5e, 0x3e, 0x6a, 0x71, 0xb4, 0xf7, 0x75,
0xc8, 0x16, 0x2f, 0x24, 0x00, 0xde, 0xe9, 0x82,
0x99, 0x5f, 0x33, 0x0b, 0xa9, 0xa6, 0x94, 0xaf,
0xcb, 0x11, 0xc3, 0xf2, 0xdb, 0x09, 0x42, 0x68,
0x29, 0x56, 0x58, 0x01, 0x56, 0xdb, 0x59, 0x03,
0x69, 0xdb, 0x7d, 0x37, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x0e, 0x00, 0x0e, 0x00, 0x6d, 0x69, 0x63, 0x72,
0x6f, 0x73, 0x6f, 0x66, 0x74, 0x2e, 0x63, 0x6f,
0x6d, 0x00 };
static char lic2[20] =
{ 0x80, 0x00, 0x10, 0x00, 0xff, 0x02, 0x10, 0x00,
0x07, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0x28, 0x14, 0x00, 0x00 };
/*****************************************************************************/
struct xrdp_sec* APP_CC
xrdp_sec_create(struct xrdp_rdp* owner, int sck)
{
struct xrdp_sec* self;
self = (struct xrdp_sec*)g_malloc(sizeof(struct xrdp_sec), 1);
self->rdp_layer = owner;
self->rc4_key_size = 1;
self->decrypt_rc4_info = g_rc4_info_create();
self->encrypt_rc4_info = g_rc4_info_create();
g_random(self->server_random, 32);
self->mcs_layer = xrdp_mcs_create(self, sck, &self->client_mcs_data,
&self->server_mcs_data);
return self;
}
/*****************************************************************************/
void APP_CC
xrdp_sec_delete(struct xrdp_sec* self)
{
if (self == 0)
{
return;
}
xrdp_mcs_delete(self->mcs_layer);
g_rc4_info_delete(self->decrypt_rc4_info);
g_rc4_info_delete(self->encrypt_rc4_info);
g_free(self->client_mcs_data.data);
g_free(self->server_mcs_data.data);
g_free(self);
}
/*****************************************************************************/
/* returns error */
int APP_CC
xrdp_sec_init(struct xrdp_sec* self, struct stream* s)
{
if (xrdp_mcs_init(self->mcs_layer, s) != 0)
{
return 1;
}
s_push_layer(s, sec_hdr, 4);
return 0;
}
/*****************************************************************************/
/* Reduce key entropy from 64 to 40 bits */
static void APP_CC
xrdp_sec_make_40bit(char* key)
{
key[0] = 0xd1;
key[1] = 0x26;
key[2] = 0x9e;
}
/*****************************************************************************/
/* returns error */
/* update an encryption key */
static int APP_CC
xrdp_sec_update(char* key, char* update_key, int key_len)
{
char shasig[20];
void* sha1_info;
void* md5_info;
void* rc4_info;
sha1_info = g_sha1_info_create();
md5_info = g_md5_info_create();
rc4_info = g_rc4_info_create();
g_sha1_clear(sha1_info);
g_sha1_transform(sha1_info, update_key, key_len);
g_sha1_transform(sha1_info, pad_54, 40);
g_sha1_transform(sha1_info, key, key_len);
g_sha1_complete(sha1_info, shasig);
g_md5_clear(md5_info);
g_md5_transform(md5_info, update_key, key_len);
g_md5_transform(md5_info, pad_92, 48);
g_md5_transform(md5_info, shasig, 20);
g_md5_complete(md5_info, key);
g_rc4_set_key(rc4_info, key, key_len);
g_rc4_crypt(rc4_info, key, key_len);
if (key_len == 8)
{
xrdp_sec_make_40bit(key);
}
g_sha1_info_delete(sha1_info);
g_md5_info_delete(md5_info);
g_rc4_info_delete(rc4_info);
return 0;
}
/*****************************************************************************/
static void APP_CC
xrdp_sec_decrypt(struct xrdp_sec* self, char* data, int len)
{
if (self->decrypt_use_count == 4096)
{
xrdp_sec_update(self->decrypt_key, self->decrypt_update_key,
self->rc4_key_len);
g_rc4_set_key(self->decrypt_rc4_info, self->decrypt_key,
self->rc4_key_len);
self->decrypt_use_count = 0;
}
g_rc4_crypt(self->decrypt_rc4_info, data, len);
self->decrypt_use_count++;
}
/*****************************************************************************/
/* returns error */
static int APP_CC
xrdp_sec_process_logon_info(struct xrdp_sec* self, struct stream* s)
{
int flags;
int len_domain;
int len_user;
int len_password;
int len_program;
int len_directory;
in_uint8s(s, 4);
in_uint32_le(s, flags);
DEBUG(("in xrdp_sec_process_logon_info flags $%x\n\r", flags));
/* this is the first test that the decrypt is working */
if ((flags & RDP_LOGON_NORMAL) != RDP_LOGON_NORMAL) /* 0x33 */
{ /* must be or error */
return 1;
}
if (flags & RDP_LOGON_AUTO)
{
}
if (flags & RDP_COMPRESSION)
{
}
in_uint16_le(s, len_domain);
in_uint16_le(s, len_user);
in_uint16_le(s, len_password);
in_uint16_le(s, len_program);
in_uint16_le(s, len_directory);
in_uint8s(s, len_domain + 2);
in_uint8s(s, len_user + 2);
in_uint8s(s, len_password + 2);
in_uint8s(s, len_program + 2);
in_uint8s(s, len_directory + 2);
return 0;
}
/*****************************************************************************/
/* returns error */
static int APP_CC
xrdp_sec_send_lic_initial(struct xrdp_sec* self)
{
struct stream* s;
make_stream(s);
init_stream(s, 8192);
if (xrdp_mcs_init(self->mcs_layer, s) != 0)
{
free_stream(s);
return 1;
}
out_uint8a(s, lic1, 322);
s_mark_end(s);
if (xrdp_mcs_send(self->mcs_layer, s) != 0)
{
free_stream(s);
return 1;
}
free_stream(s);
return 0;
}
/*****************************************************************************/
/* returns error */
static int APP_CC
xrdp_sec_send_lic_response(struct xrdp_sec* self)
{
struct stream* s;
make_stream(s);
init_stream(s, 8192);
if (xrdp_mcs_init(self->mcs_layer, s) != 0)
{
free_stream(s);
return 1;
}
out_uint8a(s, lic2, 20);
s_mark_end(s);
if (xrdp_mcs_send(self->mcs_layer, s) != 0)
{
free_stream(s);
return 1;
}
free_stream(s);
return 0;
}
/*****************************************************************************/
static void APP_CC
xrdp_sec_reverse(char* p, int len)
{
int i;
int j;
char temp;
i = 0;
j = len - 1;
while (i < j)
{
temp = p[i];
p[i] = p[j];
p[j] = temp;
i++;
j--;
}
}
/*****************************************************************************/
static void APP_CC
xrdp_sec_rsa_op(char* out, char* in, char* mod, char* exp)
{
char lexp[64];
char lmod[64];
char lin[64];
char lout[64];
int len;
g_memcpy(lexp, exp, 64);
g_memcpy(lmod, mod, 64);
g_memcpy(lin, in, 64);
xrdp_sec_reverse(lexp, 64);
xrdp_sec_reverse(lmod, 64);
xrdp_sec_reverse(lin, 64);
g_memset(lout, 0, 64);
len = g_mod_exp(lout, lin, lmod, lexp);
xrdp_sec_reverse(lout, len);
g_memcpy(out, lout, 64);
}
/*****************************************************************************/
static void APP_CC
xrdp_sec_hash_48(char* out, char* in, char* salt1, char* salt2, int salt)
{
int i;
void* sha1_info;
void* md5_info;
char pad[4];
char sha1_sig[20];
char md5_sig[16];
sha1_info = g_sha1_info_create();
md5_info = g_md5_info_create();
for (i = 0; i < 3; i++)
{
g_memset(pad, salt + i, 4);
g_sha1_clear(sha1_info);
g_sha1_transform(sha1_info, pad, i + 1);
g_sha1_transform(sha1_info, in, 48);
g_sha1_transform(sha1_info, salt1, 32);
g_sha1_transform(sha1_info, salt2, 32);
g_sha1_complete(sha1_info, sha1_sig);
g_md5_clear(md5_info);
g_md5_transform(md5_info, in, 48);
g_md5_transform(md5_info, sha1_sig, 20);
g_md5_complete(md5_info, md5_sig);
g_memcpy(out + i * 16, md5_sig, 16);
}
g_sha1_info_delete(sha1_info);
g_md5_info_delete(md5_info);
}
/*****************************************************************************/
static void APP_CC
xrdp_sec_hash_16(char* out, char* in, char* salt1, char* salt2)
{
void* md5_info;
md5_info = g_md5_info_create();
g_md5_clear(md5_info);
g_md5_transform(md5_info, in, 16);
g_md5_transform(md5_info, salt1, 32);
g_md5_transform(md5_info, salt2, 32);
g_md5_complete(md5_info, out);
g_md5_info_delete(md5_info);
}
/*****************************************************************************/
static void APP_CC
xrdp_sec_establish_keys(struct xrdp_sec* self)
{
char session_key[48];
char temp_hash[48];
char input[48];
g_memcpy(input, self->client_random, 24);
g_memcpy(input + 24, self->server_random, 24);
xrdp_sec_hash_48(temp_hash, input, self->client_random,
self->server_random, 65);
xrdp_sec_hash_48(session_key, temp_hash, self->client_random,
self->server_random, 88);
g_memcpy(self->sign_key, session_key, 16);
xrdp_sec_hash_16(self->encrypt_key, session_key + 16, self->client_random,
self->server_random);
xrdp_sec_hash_16(self->decrypt_key, session_key + 32, self->client_random,
self->server_random);
if (self->rc4_key_size == 1)
{
xrdp_sec_make_40bit(self->sign_key);
xrdp_sec_make_40bit(self->encrypt_key);
xrdp_sec_make_40bit(self->decrypt_key);
self->rc4_key_len = 8;
}
else
{
self->rc4_key_len = 16;
}
g_memcpy(self->decrypt_update_key, self->decrypt_key, 16);
g_memcpy(self->encrypt_update_key, self->encrypt_key, 16);
g_rc4_set_key(self->decrypt_rc4_info, self->decrypt_key, self->rc4_key_len);
g_rc4_set_key(self->encrypt_rc4_info, self->encrypt_key, self->rc4_key_len);
}
/*****************************************************************************/
/* returns error */
int APP_CC
xrdp_sec_recv(struct xrdp_sec* self, struct stream* s, int* chan)
{
int flags;
int len;
DEBUG((" in xrdp_sec_recv\n\r"));
if (xrdp_mcs_recv(self->mcs_layer, s, chan) != 0)
{
DEBUG((" out xrdp_sec_recv error\n\r"));
return 1;
}
in_uint32_le(s, flags);
DEBUG((" in xrdp_sec_recv flags $%x\n\r", flags));
if (flags & SEC_ENCRYPT) /* 0x08 */
{
in_uint8s(s, 8); /* signature */
xrdp_sec_decrypt(self, s->p, s->end - s->p);
}
if (flags & SEC_CLIENT_RANDOM) /* 0x01 */
{
in_uint32_le(s, len);
in_uint8a(s, self->client_crypt_random, 64);
xrdp_sec_rsa_op(self->client_random, self->client_crypt_random,
pub_mod, pri_exp);
xrdp_sec_establish_keys(self);
*chan = 1; /* just set a non existing channel and exit */
return 0;
}
if (flags & SEC_LOGON_INFO) /* 0x40 */
{
if (xrdp_sec_process_logon_info(self, s) != 0)
{
return 1;
}
if (xrdp_sec_send_lic_initial(self) != 0)
{
return 1;
}
*chan = 1; /* just set a non existing channel and exit */
return 0;
}
if (flags & SEC_LICENCE_NEG) /* 0x80 */
{
if (xrdp_sec_send_lic_response(self) != 0)
{
return 1;
}
return -1; /* special error that means send demand active */
}
DEBUG((" out xrdp_sec_recv error\n\r"));
return 0;
}
/*****************************************************************************/
/* returns error */
/* TODO needs outgoing encryption */
int APP_CC
xrdp_sec_send(struct xrdp_sec* self, struct stream* s, int flags)
{
DEBUG((" in xrdp_sec_send\n\r"));
s_pop_layer(s, sec_hdr);
out_uint32_le(s, flags);
if (xrdp_mcs_send(self->mcs_layer, s) != 0)
{
return 1;
}
DEBUG((" out xrdp_sec_send\n\r"));
return 0;
}
/*****************************************************************************/
/* prepare server mcs data to send in mcs layer */
static void APP_CC
xrdp_sec_out_mcs_data(struct xrdp_sec* self)
{
struct stream* p;
p = &self->server_mcs_data;
init_stream(p, 512);
out_uint16_be(p, 5);
out_uint16_be(p, 0x14);
out_uint8(p, 0x7c);
out_uint16_be(p, 1);
out_uint8(p, 0x2a);
out_uint8(p, 0x14);
out_uint8(p, 0x76);
out_uint8(p, 0x0a);
out_uint8(p, 1);
out_uint8(p, 1);
out_uint8(p, 0);
out_uint16_le(p, 0xc001);
out_uint8(p, 0);
out_uint8(p, 0x4d); /* M */
out_uint8(p, 0x63); /* c */
out_uint8(p, 0x44); /* D */
out_uint8(p, 0x6e); /* n */
out_uint16_be(p, 0x80fc);
out_uint16_le(p, SEC_TAG_SRV_INFO);
out_uint16_le(p, 8); /* len */
out_uint8(p, 4); /* 4 = rdp5 1 = rdp4 */
out_uint8(p, 0);
out_uint8(p, 8);
out_uint8(p, 0);
out_uint16_le(p, SEC_TAG_SRV_CHANNELS);
out_uint16_le(p, 8); /* len */
out_uint8(p, 0xeb);
out_uint8(p, 3);
out_uint8(p, 0);
out_uint8(p, 0);
out_uint16_le(p, SEC_TAG_SRV_CRYPT);
out_uint16_le(p, 0x00ec); /* len is 236 */
out_uint32_le(p, 1); /* key len 1 = 40 bit 2 = 128 bit */
out_uint32_le(p, 1); /* crypt level 1 = low 2 = medium 3 = high */
out_uint32_le(p, 32); /* 32 bytes random len */
out_uint32_le(p, 0xb8); /* 184 bytes rsa info(certificate) len */
out_uint8a(p, self->server_random, 32);
/* here to end is certificate */
/* HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\ */
/* TermService\Parameters\Certificate */
out_uint32_le(p, 1);
out_uint32_le(p, 1);
out_uint32_le(p, 1);
out_uint16_le(p, SEC_TAG_PUBKEY);
out_uint16_le(p, 0x005c); /* 92 bytes length of SEC_TAG_PUBKEY */
out_uint32_le(p, SEC_RSA_MAGIC);
out_uint32_le(p, 0x48); /* 72 bytes modulus len */
out_uint32_be(p, 0x00020000);
out_uint32_be(p, 0x3f000000);
out_uint8a(p, pub_exp, 4); /* pub exp */
out_uint8a(p, pub_mod, 64); /* pub mod */
out_uint8s(p, 8); /* pad */
out_uint16_le(p, SEC_TAG_KEYSIG);
out_uint16_le(p, 72); /* len */
out_uint8a(p, pub_sig, 64); /* pub sig */
out_uint8s(p, 8); /* pad */
/* end certificate */
s_mark_end(p);
}
/*****************************************************************************/
int APP_CC
xrdp_sec_incoming(struct xrdp_sec* self)
{
DEBUG(("in xrdp_sec_incoming\n\r"));
xrdp_sec_out_mcs_data(self);
if (xrdp_mcs_incoming(self->mcs_layer) != 0)
{
return 1;
}
#ifdef XRDP_DEBUG
g_printf("client mcs data received\n\r");
g_hexdump(self->client_mcs_data.data,
self->client_mcs_data.end - self->client_mcs_data.data);
g_printf("server mcs data sent\n\r");
g_hexdump(self->server_mcs_data.data,
self->server_mcs_data.end - self->server_mcs_data.data);
#endif
DEBUG(("out xrdp_sec_incoming\n\r"));
return 0;
}
/*****************************************************************************/
int APP_CC
xrdp_sec_disconnect(struct xrdp_sec* self)
{
return xrdp_mcs_disconnect(self->mcs_layer);
}

@ -0,0 +1,146 @@
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
xrdp: A Remote Desktop Protocol server.
Copyright (C) Jay Sorg 2004-2005
tcp layer
*/
#include "libxrdp.h"
/*****************************************************************************/
struct xrdp_tcp* APP_CC
xrdp_tcp_create(struct xrdp_iso* owner, int sck)
{
struct xrdp_tcp* self;
self = (struct xrdp_tcp*)g_malloc(sizeof(struct xrdp_tcp), 1);
self->iso_layer = owner;
self->sck = sck;
return self;
}
/*****************************************************************************/
void APP_CC
xrdp_tcp_delete(struct xrdp_tcp* self)
{
g_free(self);
}
/*****************************************************************************/
/* get out stream ready for data */
/* returns error */
int APP_CC
xrdp_tcp_init(struct xrdp_tcp* self, struct stream* s)
{
init_stream(s, 8192);
return 0;
}
/*****************************************************************************/
/* returns error */
int APP_CC
xrdp_tcp_recv(struct xrdp_tcp* self, struct stream* s, int len)
{
int rcvd;
if (self->sck_closed)
{
DEBUG((" in xrdp_tcp_recv, sck closed\n\r"));
return 1;
}
DEBUG((" in xrdp_tcp_recv, gota get %d bytes\n\r", len));
init_stream(s, len);
while (len > 0)
{
rcvd = g_tcp_recv(self->sck, s->end, len, 0);
if (rcvd == -1)
{
if (g_tcp_last_error_would_block(self->sck))
{
g_sleep(1);
}
else
{
self->sck_closed = 1;
DEBUG((" error = -1 in xrdp_tcp_recv socket %d\n\r", self->sck));
return 1;
}
}
else if (rcvd == 0)
{
self->sck_closed = 1;
DEBUG((" error = 0 in xrdp_tcp_recv socket %d\n\r", self->sck));
return 1;
}
else
{
s->end += rcvd;
len -= rcvd;
}
}
DEBUG((" out xrdp_tcp_recv\n\r"));
return 0;
}
/*****************************************************************************/
/* returns error */
int APP_CC
xrdp_tcp_send(struct xrdp_tcp* self, struct stream* s)
{
int len;
int total;
int sent;
if (self->sck_closed)
{
DEBUG((" in xrdp_tcp_send, sck closed\n\r"));
return 1;
}
len = s->end - s->data;
DEBUG((" in xrdp_tcp_send, gota send %d bytes\n\r", len));
total = 0;
while (total < len)
{
sent = g_tcp_send(self->sck, s->data + total, len - total, 0);
if (sent == -1)
{
if (g_tcp_last_error_would_block(self->sck))
{
g_sleep(1);
}
else
{
self->sck_closed = 1;
DEBUG((" error = -1 in xrdp_tcp_send socket %d\n\r", self->sck));
return 1;
}
}
else if (sent == 0)
{
self->sck_closed = 1;
DEBUG((" error = 0 in xrdp_tcp_send socket %d\n\r", self->sck));
return 1;
}
else
{
total = total + sent;
}
}
DEBUG((" out xrdp_tcp_send, sent %d bytes ok\n\r", len));
return 0;
}

@ -3,7 +3,7 @@
# in verify_user.c
#USE_PAM = ""
SESMANOBJ = sesman.o verify_user.o os_calls.o d3des.o
SESMANOBJ = sesman.o verify_user.o ../common/os_calls.o ../common/d3des.o
ifdef USE_PAM
CFLAGS = -Wall -O2 -I../common -DUSE_PAM
@ -27,9 +27,3 @@ sesman: $(SESMANOBJ)
clean:
rm -f $(SESMANOBJ) sesman
os_calls.o:
$(CC) $(C_OS_FLAGS) ../common/os_calls.c
d3des.o:
$(CC) $(C_OS_FLAGS) ../common/d3des.c

@ -121,7 +121,8 @@ int lib_send(struct vnc* v, char* data, int len)
}
/******************************************************************************/
int lib_mod_event(struct vnc* v, int msg, int param1, int param2)
int lib_mod_event(struct vnc* v, int msg, long param1, long param2,
long param3, long param4)
{
struct stream* s;
int key;

@ -32,7 +32,8 @@ struct vnc
/* client functions */
int (*mod_start)(struct vnc* v, int w, int h, int bpp);
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, long param1, long param2,
long param3, long param4);
int (*mod_signal)(struct vnc* v);
int (*mod_end)(struct vnc* v);
int (*mod_set_param)(struct vnc* v, char* name, char* value);

Loading…
Cancel
Save