jh163888/xrdp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

win32 compile changes

Browse Source
This commit is contained in:
jsorg71 2004-10-21 03:18:23 +00:00
parent 330a4ffb98
commit b4b62a619a
10 changed files with 228 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
xrdp/makefile_win32 Normal file
View File

@ -0,0 +1,28 @@
# 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 all'
#
XRDPOBJ = xrdp.obj os_calls.obj xrdp_tcp.obj xrdp_iso.obj xrdp_mcs.obj \
xrdp_sec.obj xrdp_rdp.obj xrdp_process.obj xrdp_listen.obj \
xrdp_orders.obj xrdp_bitmap.obj xrdp_wm.obj xrdp_painter.obj \
xrdp_list.obj xrdp_region.obj xrdp_cache.obj xrdp_font.obj \
funcs.obj
CFLAGS = -w- -O2 -Ic:\borland\bcc55\include -Ic:\openssl\include
LDFLAGS = -Lc:\borland\bcc55\lib
xrdp: $(XRDPOBJ)
$(CC) $(LDFLAGS) libeay32.lib $(XRDPOBJ)
all: lib xrdp
clean:
del *.obj *.o xrdp.exe
lib:
implib -a -w libeay32.lib c:\windows\system32\libeay32.dll

128
xrdp/os_calls.c
View File

@ -20,40 +20,53 @@
*/
#ifdef _WIN32
#include <windows.h>
#include <winsock.h>
#else
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/types.h>
#endif
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
#include <stdarg.h>
#include <stdio.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <openssl/rc4.h>
#include <openssl/md5.h>
#include <openssl/sha.h>
#include <openssl/bn.h>
#include "xrdp.h"
//#define MEMLEAK
#ifdef _WIN32
static CRITICAL_SECTION g_term_mutex;
#else
static pthread_mutex_t g_term_mutex = PTHREAD_MUTEX_INITIALIZER;
#endif
static int g_term = 0;
#ifdef MEMLEAK
int g_memsize = 0;
int g_memid = 0;
static int g_memsize = 0;
static int g_memid = 0;
struct xrdp_list* g_memlist = 0;
#endif
/*****************************************************************************/
int g_init_system(void)
{
#ifdef _WIN32
WSADATA w;
WSAStartup(2, &w);
InitializeCriticalSection(&g_term_mutex);
#endif
#ifdef MEMLEAK
g_memlist = xrdp_list_create();
#endif
@ -63,6 +76,10 @@ int g_init_system(void)
/*****************************************************************************/
int g_exit_system(void)
{
#ifdef _WIN32
WSACleanup();
DeleteCriticalSection(&g_term_mutex);
#endif
#ifdef MEMLEAK
int i;
struct xrdp_mem* p;
@ -223,17 +240,26 @@ int g_tcp_socket(void)
/*****************************************************************************/
void g_tcp_close(int sck)
{
#ifdef _WIN32
closesocket(sck);
#else
close(sck);
#endif
}
/*****************************************************************************/
int g_tcp_set_non_blocking(int sck)
{
int i;
unsigned long i;
i = fcntl(sck, F_GETFL);
#ifdef _WIN32
i = 1;
ioctlsocket(sck, FIONBIO, &i);
#else
i = fcntl(sck, F_GETFL);
i = i | O_NONBLOCK;
fcntl(sck, F_SETFL, i);
#endif
return 0;
}
@ -259,7 +285,11 @@ int g_tcp_listen(int sck)
int g_tcp_accept(int sck)
{
struct sockaddr_in s;
#ifdef _WIN32
signed int i;
#else
unsigned int i;
#endif
i = sizeof(struct sockaddr_in);
memset(&s, 0, i);
@ -281,7 +311,11 @@ int g_tcp_send(int sck, void* ptr, int len, int flags)
/*****************************************************************************/
int g_tcp_last_error_would_block(int sck)
{
#ifdef _WIN32
return WSAGetLastError() == WSAEWOULDBLOCK;
#else
return errno == EWOULDBLOCK;
#endif
}
/*****************************************************************************/
@ -293,7 +327,7 @@ int g_tcp_select(int sck)
time.tv_sec = 0;
time.tv_usec = 0;
FD_ZERO(&rfds);
FD_SET(sck, &rfds);
FD_SET(((unsigned int)sck), &rfds);
return select(sck + 1, &rfds, 0, 0, &time);
}
@ -302,33 +336,58 @@ int g_is_term(void)
{
int rv;
#ifdef _WIN32
EnterCriticalSection(&g_term_mutex);
rv = g_term;
LeaveCriticalSection(&g_term_mutex);
#else
pthread_mutex_lock(&g_term_mutex);
rv = g_term;
pthread_mutex_unlock(&g_term_mutex);
#endif
return rv;
}
/*****************************************************************************/
void g_set_term(int in_val)
{
#ifdef _WIN32
EnterCriticalSection(&g_term_mutex);
g_term = in_val;
LeaveCriticalSection(&g_term_mutex);
#else
pthread_mutex_lock(&g_term_mutex);
g_term = in_val;
pthread_mutex_unlock(&g_term_mutex);
#endif
}
/*****************************************************************************/
void g_sleep(int msecs)
{
#ifdef _WIN32
Sleep(msecs);
#else
usleep(msecs * 1000);
#endif
}
/*****************************************************************************/
int g_thread_create(void* (*start_routine)(void*), void* arg)
#ifdef _WIN32
int g_thread_create(unsigned long (__stdcall * start_routine)(void*), void* arg)
{
DWORD thread;
return !CreateThread(0, 0, start_routine, arg, 0, &thread);
}
#else
int g_thread_create(void* (* start_routine)(void*), void* arg)
{
pthread_t thread;
return pthread_create(&thread, 0, start_routine, arg);
}
#endif
/* rc4 stuff */
@ -451,6 +510,9 @@ int g_mod_exp(char* out, char* in, char* mod, char* exp)
/*****************************************************************************/
void g_random(char* data, int len)
{
#ifdef _WIN32
memset(data, 0x44, len);
#else
int fd;
memset(data, 0x44, len);
@ -462,6 +524,7 @@ void g_random(char* data, int len)
read(fd, data, len);
close(fd);
}
#endif
}
/*****************************************************************************/
@ -479,13 +542,23 @@ int g_memcmp(void* s1, void* s2, int len)
/*****************************************************************************/
int g_file_open(char* file_name)
{
#ifdef _WIN32
return (int)CreateFile(file_name, GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
0, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
#else
return open(file_name, O_RDWR | O_CREAT);
#endif
}
/*****************************************************************************/
int g_file_close(int fd)
{
#ifdef _WIN32
CloseHandle((HANDLE)fd);
#else
close(fd);
#endif
return 0;
}
@ -493,27 +566,49 @@ int g_file_close(int fd)
/* read from file*/
int g_file_read(int fd, char* ptr, int len)
{
#ifdef _WIN32
if (ReadFile((HANDLE)fd, (LPVOID)ptr, (DWORD)len, (LPDWORD)&len, 0))
return len;
else
return -1;
#else
return read(fd, ptr, len);
#endif
}
/*****************************************************************************/
/* write to file */
int g_file_write(int fd, char* ptr, int len)
{
#ifdef _WIN32
if (WriteFile((HANDLE)fd, (LPVOID)ptr, (DWORD)len, (LPDWORD)&len, 0))
return len;
else
return -1;
#else
return write(fd, ptr, len);
#endif
}
/*****************************************************************************/
/* move file pointer */
int g_file_seek(int fd, int offset)
{
#ifdef _WIN32
return SetFilePointer((HANDLE)fd, offset, 0, FILE_BEGIN);
#else
return lseek(fd, offset, SEEK_SET);
#endif
}
/*****************************************************************************/
/* do a write lock on a file */
/* return boolean */
int g_file_lock(int fd, int start, int len)
{
#ifdef _WIN32
return LockFile((HANDLE)fd, start, 0, len, 0);
#else
struct flock lock;
lock.l_type = F_WRLCK;
@ -523,6 +618,7 @@ int g_file_lock(int fd, int start, int len)
if (fcntl(fd, F_SETLK, &lock) == -1)
return 0;
return 1;
#endif
}
/*****************************************************************************/

3
xrdp/xrdp.c
View File

@ -26,9 +26,8 @@ static struct xrdp_listen* g_listen = 0;
/*****************************************************************************/
/* i can't get stupid in_val to work, hum using global var for now */
void* xrdp_listen_run(void* in_val)
THREAD_RV THREAD_CC xrdp_listen_run(void* in_val)
{
DEBUG(("listener started\n\r"));
xrdp_listen_main_loop(g_listen);
DEBUG(("listener done\n\r"));

10
xrdp/xrdp.h
View File

@ -68,6 +68,14 @@
/* font macros */
#define FONT_DATASIZE(f) ((((f)->height * (((f)->width + 7) / 8)) + 3) & ~3);
#ifdef _WIN32
#define THREAD_RV unsigned long
#define THREAD_CC __stdcall
#else
#define THREAD_RV void*
#define THREAD_CC
#endif
/* os_calls.c */
int g_init_system(void);
int g_exit_system(void);
@ -93,7 +101,7 @@ int g_tcp_select(int sck);
int g_is_term(void);
void g_set_term(int in_val);
void g_sleep(int msecs);
int g_thread_create(void* (*start_routine)(void*), void* arg);
int g_thread_create(THREAD_RV (THREAD_CC * start_routine)(void*), void* arg);
void* g_rc4_info_create(void);
void g_rc4_info_delete(void* rc4_info);
void g_rc4_set_key(void* rc4_info, char* key, int len);

3
xrdp/xrdp_bitmap.c
View File

@ -532,8 +532,7 @@ int xrdp_bitmap_invalidate(struct xrdp_bitmap* self, struct xrdp_rect* rect)
xrdp_painter_fill_rect(painter, self, 1, 1, self->width - 2, 1);
/* draw text */
painter->fg_color = self->wm->black;
xrdp_painter_draw_text(painter, self, 2, 2, self->caption);
// xrdp_painter_draw_text(painter, self, 2, 2, "hi");
xrdp_painter_draw_text(painter, self, 4, 2, self->caption);
}
else if (self->type == WND_TYPE_LABEL) /* 6 */
{

2
xrdp/xrdp_listen.c
View File

@ -108,7 +108,7 @@ int xrdp_listen_delete_pro(struct xrdp_listen* self, struct xrdp_process* pro)
/*****************************************************************************/
/* i can't get stupid in_val to work, hum using global var for now */
void* xrdp_process_run(void* in_val)
THREAD_RV THREAD_CC xrdp_process_run(void* in_val)
{
DEBUG(("process started\n\r"));
xrdp_process_main_loop(g_process);

2
xrdp/xrdp_orders.c
View File

@ -642,7 +642,7 @@ int xrdp_orders_dest_blt(struct xrdp_orders* self, int x, int y,
}
if (rop != self->dest_blt_rop)
{
present |= 0x0010;
present |= 0x10;
out_uint8(self->out_s, rop);
self->dest_blt_rop = rop;
}

132
xrdp/xrdp_painter.c
View File

@ -159,12 +159,16 @@ int xrdp_painter_fill_rect(struct xrdp_painter* self,
i = 0;
while (xrdp_region_get_rect(region, i, &rect) == 0)
{
DEBUG(("sending rect order %d %d %d %d\n\r", rect.left, rect.top,
rect.right, rect.bottom));
xrdp_orders_rect(self->orders, rect.left, rect.top,
rect.right - rect.left,
rect.bottom - rect.top,
self->fg_color, 0);
if (!ISRECTEMPTY(rect))
{
DEBUG(("sending rect order %d %d %d %d\n\r",
rect.left, rect.top,
rect.right, rect.bottom));
xrdp_orders_rect(self->orders, rect.left, rect.top,
rect.right - rect.left,
rect.bottom - rect.top,
self->fg_color, 0);
}
i++;
}
xrdp_region_delete(region);
@ -196,13 +200,17 @@ int xrdp_painter_fill_rect2(struct xrdp_painter* self,
i = 0;
while (xrdp_region_get_rect(region, i, &rect) == 0)
{
DEBUG(("sending rect2 order %d %d %d %d\n\r", rect.left, rect.top,
rect.right, rect.bottom));
xrdp_orders_pat_blt(self->orders, rect.left, rect.top,
rect.right - rect.left,
rect.bottom - rect.top,
self->rop, self->bg_color, self->fg_color,
&self->brush, 0);
if (!ISRECTEMPTY(rect))
{
DEBUG(("sending rect2 order %d %d %d %d\n\r",
rect.left, rect.top,
rect.right, rect.bottom));
xrdp_orders_pat_blt(self->orders, rect.left, rect.top,
rect.right - rect.left,
rect.bottom - rect.top,
self->rop, self->bg_color, self->fg_color,
&self->brush, 0);
}
i++;
}
xrdp_region_delete(region);
@ -269,47 +277,50 @@ int xrdp_painter_draw_bitmap(struct xrdp_painter* self,
k = 0;
while (xrdp_region_get_rect(region, k, &rect) == 0)
{
MAKERECT(rect1, x1, y1, w, h);
if (rect_intersect(&rect, &rect1, &rect2))
if (!ISRECTEMPTY(rect))
{
ok = 1;
if (self->use_clip)
MAKERECT(rect1, x1, y1, w, h);
if (rect_intersect(&rect, &rect1, &rect2))
{
rect = self->clip;
RECTOFFSET(rect, x, y);
if (!rect_intersect(&rect2, &rect, &rect1))
ok = 0;
}
else
rect1 = rect2;
if (ok)
{
rect1.right--;
rect1.bottom--;
/* check these so ms client don't crash */
if (x1 + w >= self->wm->screen->width)
w = self->wm->screen->width - x1;
if (y1 + h >= self->wm->screen->height)
h = self->wm->screen->height - y1;
if (w > 0 && h > 0 && x1 + w > 0 && y1 + h > 0)
ok = 1;
if (self->use_clip)
{
srcx = 0;
srcy = 0;
if (x1 < 0)
rect = self->clip;
RECTOFFSET(rect, x, y);
if (!rect_intersect(&rect2, &rect, &rect1))
ok = 0;
}
else
rect1 = rect2;
if (ok)
{
rect1.right--;
rect1.bottom--;
/* check these so ms client don't crash */
if (x1 + w >= self->wm->screen->width)
w = self->wm->screen->width - x1;
if (y1 + h >= self->wm->screen->height)
h = self->wm->screen->height - y1;
if (w > 0 && h > 0 && x1 + w > 0 && y1 + h > 0)
{
w = w + x1;
srcx = srcx - x1;
x1 = 0;
srcx = 0;
srcy = 0;
if (x1 < 0)
{
w = w + x1;
srcx = srcx - x1;
x1 = 0;
}
if (y1 < 0)
{
h = h + y1;
srcy = srcy - y1;
y1 = 0;
}
xrdp_orders_mem_blt(self->orders, cache_id, palette_id,
x1, y1, w, h, self->rop, srcx, srcy,
cache_idx, &rect1);
}
if (y1 < 0)
{
h = h + y1;
srcy = srcy - y1;
y1 = 0;
}
xrdp_orders_mem_blt(self->orders, cache_id, palette_id,
x1, y1, w, h, self->rop, srcx, srcy,
cache_idx, &rect1);
}
}
}
@ -436,17 +447,20 @@ int xrdp_painter_draw_text(struct xrdp_painter* self,
k = 0;
while (xrdp_region_get_rect(region, k, &rect) == 0)
{
if (rect_intersect(&rect, &clip_rect, &draw_rect))
if (!ISRECTEMPTY(rect))
{
x1 = x;
y1 = y + total_height;
draw_rect.right--;
draw_rect.bottom--;
flags = 0x03; /* 0x73; TEXT2_IMPLICIT_X and something else */
xrdp_orders_text(self->orders, f, flags, 0,
font->color, 0,
x, y, x + total_width, y + total_height,
0, 0, 0, 0, x1, y1, data, len * 2, &draw_rect);
if (rect_intersect(&rect, &clip_rect, &draw_rect))
{
x1 = x;
y1 = y + total_height;
draw_rect.right--;
draw_rect.bottom--;
flags = 0x03; /* 0x73; TEXT2_IMPLICIT_X and something else */
xrdp_orders_text(self->orders, f, flags, 0,
font->color, 0,
x, y, x + total_width, y + total_height,
0, 0, 0, 0, x1, y1, data, len * 2, &draw_rect);
}
}
k++;
}

1
xrdp/xrdp_types.h
View File

@ -390,6 +390,7 @@ struct xrdp_bitmap
struct xrdp_list* child_list;
struct xrdp_wm* wm;
int cursor;
int edit_pos;
/* msg 1 = click 2 = mouse move 3 = paint 100 = modal result */
int (*notify)(struct xrdp_bitmap* wnd, struct xrdp_bitmap* sender,
int msg, int param1, int param2);

2
xrdp/xrdp_wm.c
View File

@ -31,7 +31,7 @@ struct xrdp_wm* xrdp_wm_create(struct xrdp_process* owner)
self = (struct xrdp_wm*)g_malloc(sizeof(struct xrdp_wm), 1);
self->screen = xrdp_bitmap_create(owner->rdp_layer->width,
owner->rdp_layer->height,
owner->rdp_layer->bpp, 2);
owner->rdp_layer->bpp, WND_TYPE_SCREEN);
self->screen->wm = self;
self->pro_layer = owner;
self->orders = owner->orders;