From 9611a5f111a54492ff12f1c864736bec46c8d7cb Mon Sep 17 00:00:00 2001 From: jsorg71 Date: Fri, 7 Jan 2005 01:05:30 +0000 Subject: [PATCH] move some file to common --- vnc/Makefile | 6 +- vnc/os_calls.c | 794 ------------------------------------------------- vnc/parse.h | 299 ------------------- vnc/vnc.c | 162 +++++++--- vnc/vnc.h | 124 ++------ 5 files changed, 143 insertions(+), 1242 deletions(-) delete mode 100644 vnc/os_calls.c delete mode 100644 vnc/parse.h diff --git a/vnc/Makefile b/vnc/Makefile index e7f8430f..9e70862f 100644 --- a/vnc/Makefile +++ b/vnc/Makefile @@ -1,6 +1,6 @@ -VNCOBJ = os_calls.o vnc.o d3des.o vncauth.o -CFLAGS = -Wall -O2 +VNCOBJ = ../common/os_calls.o vnc.o d3des.o vncauth.o +CFLAGS = -Wall -O2 -I../common LDFLAGS = -shared LIBS = -ldl CC = gcc @@ -11,4 +11,4 @@ vnc: $(VNCOBJ) $(CC) $(LDFLAGS) -o libvnc.so $(VNCOBJ) $(LIBS) clean: - rm -f *.o libvnc.so + rm -f $(VNCOBJ) libvnc.so diff --git a/vnc/os_calls.c b/vnc/os_calls.c deleted file mode 100644 index c8668749..00000000 --- a/vnc/os_calls.c +++ /dev/null @@ -1,794 +0,0 @@ -/* - 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 - - generic operating system calls - -*/ - -#ifdef _WIN32 -#include -#include -#else -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#endif -#include -#include -#include -#include -#include -#include -#include -#include -#include - -//#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 -#include "xrdp.h" -#endif - -#ifdef MEMLEAK -static int g_memsize = 0; -static int g_memid = 0; -static 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 - return 0; -} - -/*****************************************************************************/ -int g_exit_system(void) -{ -#ifdef _WIN32 - WSACleanup(); - DeleteCriticalSection(&g_term_mutex); -#endif -#ifdef MEMLEAK - int i; - struct xrdp_mem* p; - - for (i = 0; i < g_memlist->count; i++) - { - p = (struct xrdp_mem*)xrdp_list_get_item(g_memlist, i); - g_printf("leak size %d id %d\n\r", p->size, p->id); - } - g_printf("mem %d\n\r", g_memsize); - xrdp_list_delete(g_memlist); - g_memlist = 0; -#endif - return 0; -} - -/*****************************************************************************/ -void* g_malloc(int size, int zero) -{ -#ifdef MEMLEAK - char* rv; - struct xrdp_mem* p; - - rv = (char*)malloc(size + sizeof(struct xrdp_mem)); - if (zero) - memset(rv, 0, size + sizeof(struct xrdp_mem)); - g_memsize += size; - p = (struct xrdp_mem*)rv; - p->size = size; - p->id = g_memid; - if (g_memlist != 0) - xrdp_list_add_item(g_memlist, (int)p); - g_memid++; - return rv + sizeof(struct xrdp_mem); -#else - char* rv; - - rv = (char*)malloc(size); - if (zero) - memset(rv, 0, size); - return rv; -#endif -} - -/*****************************************************************************/ -void* g_malloc1(int size, int zero) -{ - char* rv; - - rv = (char*)malloc(size); - if (zero) - memset(rv, 0, size); - return rv; -} - -/*****************************************************************************/ -void g_free(void* ptr) -{ -#ifdef MEMLEAK - struct xrdp_mem* p; - int i; - - if (ptr != 0) - { - p = (struct xrdp_mem*)(((char*)ptr) - sizeof(struct xrdp_mem)); - g_memsize -= p->size; - i = xrdp_list_index_of(g_memlist, (int)p); - if (i >= 0) - xrdp_list_remove_item(g_memlist, i); - free(p); - } -#else - if (ptr != 0) - { - free(ptr); - } -#endif -} - -/*****************************************************************************/ -void g_free1(void* ptr) -{ - if (ptr != 0) - { - free(ptr); - } -} - -/*****************************************************************************/ -void g_sleep(int msecs) -{ -#ifdef _WIN32 - Sleep(msecs); -#else - usleep(msecs * 1000); -#endif -} - -/*****************************************************************************/ -void g_printf(char* format, ...) -{ - va_list ap; - - va_start(ap, format); - vfprintf(stdout, format, ap); - va_end(ap); -} - -/*****************************************************************************/ -/* produce a hex dump */ -void g_hexdump(char* p, int len) -{ - unsigned char* line; - int i; - int thisline; - int offset; - - line = (unsigned char*)p; - offset = 0; - while (offset < len) - { - printf("%04x ", offset); - thisline = len - offset; - if (thisline > 16) - thisline = 16; - for (i = 0; i < thisline; i++) - printf("%02x ", line[i]); - for (; i < 16; i++) - printf(" "); - for (i = 0; i < thisline; i++) - printf("%c", (line[i] >= 0x20 && line[i] < 0x7f) ? line[i] : '.'); - printf("\n"); - offset += thisline; - line += thisline; - } -} - -/*****************************************************************************/ -void g_memset(void* ptr, int val, int size) -{ - memset(ptr, val, size); -} - -/*****************************************************************************/ -void g_memcpy(void* d_ptr, const void* s_ptr, int size) -{ - memcpy(d_ptr, s_ptr, size); -} - -/*****************************************************************************/ -int g_getchar(void) -{ - return getchar(); -} - -/*****************************************************************************/ -int g_tcp_socket(void) -{ - int rv; - int i; - - i = 1; - rv = socket(PF_INET, SOCK_STREAM, 0); - setsockopt(rv, IPPROTO_TCP, TCP_NODELAY, (void*)&i, sizeof(i)); - return rv; -} - -/*****************************************************************************/ -int g_tcp_local_socket(void) -{ - int rv; - - rv = socket(PF_LOCAL, SOCK_STREAM, 0); - return rv; -} - -/*****************************************************************************/ -void g_tcp_close(int sck) -{ -#ifdef _WIN32 - closesocket(sck); -#else - close(sck); -#endif -} - -/*****************************************************************************/ -int g_tcp_connect(int sck, char* address, char* port) -{ - struct sockaddr_in s; - struct hostent* h; - - g_memset(&s, 0, sizeof(struct sockaddr_in)); - s.sin_family = AF_INET; - s.sin_port = htons(atoi(port)); - s.sin_addr.s_addr = inet_addr(address); - if (s.sin_addr.s_addr == INADDR_NONE) - { - h = gethostbyname(address); - if (h != 0) - if (h->h_name != 0) - if (h->h_addr_list != 0) - if ((*(h->h_addr_list)) != 0) - s.sin_addr.s_addr = *((int*)(*(h->h_addr_list))); - } - return connect(sck, (struct sockaddr*)&s, sizeof(struct sockaddr_in)); -} - -/*****************************************************************************/ -int g_tcp_set_non_blocking(int sck) -{ - unsigned long i; - -#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; -} - -/*****************************************************************************/ -int g_tcp_bind(int sck, char* port) -{ - struct sockaddr_in s; - - memset(&s, 0, sizeof(struct sockaddr_in)); - s.sin_family = AF_INET; - s.sin_port = htons(atoi(port)); - s.sin_addr.s_addr = INADDR_ANY; - return bind(sck, (struct sockaddr*)&s, sizeof(struct sockaddr_in)); -} - -/*****************************************************************************/ -int g_tcp_local_bind(int sck, char* port) -{ - struct sockaddr_un s; - - memset(&s, 0, sizeof(struct sockaddr_un)); - s.sun_family = AF_UNIX; - strcpy(s.sun_path, port); - return bind(sck, (struct sockaddr*)&s, sizeof(struct sockaddr_un)); -} - -/*****************************************************************************/ -int g_tcp_listen(int sck) -{ - return listen(sck, 2); -} - -/*****************************************************************************/ -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); - return accept(sck, (struct sockaddr*)&s, &i); -} - -/*****************************************************************************/ -int g_tcp_last_error_would_block(int sck) -{ -#ifdef _WIN32 - return WSAGetLastError() == WSAEWOULDBLOCK; -#else - return errno == EWOULDBLOCK; -#endif -} - -/*****************************************************************************/ -int g_tcp_recv(int sck, void* ptr, int len, int flags) -{ - return recv(sck, ptr, len, flags); -} - -/*****************************************************************************/ -int g_tcp_force_recv(int sck, char* data, int len) -{ - int rcvd; - - while (len > 0) - { - rcvd = g_tcp_recv(sck, data, len, 0); - if (rcvd == -1) - { - if (g_tcp_last_error_would_block(sck)) - g_sleep(1); - else - return 1; - } - else if (rcvd == 0) - return 1; - else - { - data += rcvd; - len -= rcvd; - } - } - return 0; -} - -/*****************************************************************************/ -int g_tcp_send(int sck, void* ptr, int len, int flags) -{ - return send(sck, ptr, len, flags); -} - -/*****************************************************************************/ -int g_tcp_force_send(int sck, char* data, int len) -{ - int sent; - - while (len > 0) - { - sent = g_tcp_send(sck, data, len, 0); - if (sent == -1) - { - if (g_tcp_last_error_would_block(sck)) - g_sleep(1); - else - return 1; - } - else if (sent == 0) - return 1; - else - { - data += sent; - len -= sent; - } - } - return 0; -} - -/*****************************************************************************/ -int g_tcp_select(int sck1, int sck2) -{ - fd_set rfds; - struct timeval time; - int max; - - time.tv_sec = 0; - time.tv_usec = 0; - FD_ZERO(&rfds); - FD_SET(((unsigned int)sck1), &rfds); - FD_SET(((unsigned int)sck2), &rfds); - max = sck1; - if (sck2 > max) - max = sck2; - return select(max + 1, &rfds, 0, 0, &time); -} - -/*****************************************************************************/ -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 -} - -/*****************************************************************************/ -#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 */ - -/*****************************************************************************/ -void* g_rc4_info_create(void) -{ - return g_malloc(sizeof(RC4_KEY), 1);; -} - -/*****************************************************************************/ -void g_rc4_info_delete(void* rc4_info) -{ - g_free(rc4_info); -} - -/*****************************************************************************/ -void g_rc4_set_key(void* rc4_info, char* key, int len) -{ - RC4_set_key((RC4_KEY*)rc4_info, len, (unsigned char*)key); -} - -/*****************************************************************************/ -void g_rc4_crypt(void* rc4_info, char* data, int len) -{ - RC4((RC4_KEY*)rc4_info, len, (unsigned char*)data, (unsigned char*)data); -} - -/* sha1 stuff */ - -/*****************************************************************************/ -void* g_sha1_info_create(void) -{ - return g_malloc(sizeof(SHA_CTX), 1); -} - -/*****************************************************************************/ -void g_sha1_info_delete(void* sha1_info) -{ - g_free(sha1_info); -} - -/*****************************************************************************/ -void g_sha1_clear(void* sha1_info) -{ - SHA1_Init((SHA_CTX*)sha1_info); -} - -/*****************************************************************************/ -void g_sha1_transform(void* sha1_info, char* data, int len) -{ - SHA1_Update((SHA_CTX*)sha1_info, data, len); -} - -/*****************************************************************************/ -void g_sha1_complete(void* sha1_info, char* data) -{ - SHA1_Final((unsigned char*)data, (SHA_CTX*)sha1_info); -} - -/* md5 stuff */ - -/*****************************************************************************/ -void* g_md5_info_create(void) -{ - return g_malloc(sizeof(MD5_CTX), 1); -} - -/*****************************************************************************/ -void g_md5_info_delete(void* md5_info) -{ - g_free(md5_info); -} - -/*****************************************************************************/ -void g_md5_clear(void* md5_info) -{ - MD5_Init((MD5_CTX*)md5_info); -} - -/*****************************************************************************/ -void g_md5_transform(void* md5_info, char* data, int len) -{ - MD5_Update((MD5_CTX*)md5_info, data, len); -} - -/*****************************************************************************/ -void g_md5_complete(void* md5_info, char* data) -{ - MD5_Final((unsigned char*)data, (MD5_CTX*)md5_info); -} - -/*****************************************************************************/ -int g_mod_exp(char* out, char* in, char* mod, char* exp) -{ - BN_CTX* ctx; - BIGNUM lmod; - BIGNUM lexp; - BIGNUM lin; - BIGNUM lout; - int rv; - - ctx = BN_CTX_new(); - BN_init(&lmod); - BN_init(&lexp); - BN_init(&lin); - BN_init(&lout); - BN_bin2bn((unsigned char*)mod, 64, &lmod); - BN_bin2bn((unsigned char*)exp, 64, &lexp); - BN_bin2bn((unsigned char*)in, 64, &lin); - BN_mod_exp(&lout, &lin, &lexp, &lmod, ctx); - rv = BN_bn2bin(&lout, (unsigned char*)out); - BN_free(&lin); - BN_free(&lout); - BN_free(&lexp); - BN_free(&lmod); - BN_CTX_free(ctx); - return rv; -} - -/*****************************************************************************/ -void g_random(char* data, int len) -{ -#ifdef _WIN32 - memset(data, 0x44, len); -#else - int fd; - - memset(data, 0x44, len); - fd = open("/dev/urandom", O_RDONLY); - if (fd == -1) - fd = open("/dev/random", O_RDONLY); - if (fd != -1) - { - read(fd, data, len); - close(fd); - } -#endif -} - -/*****************************************************************************/ -int g_abs(int i) -{ - return abs(i); -} - -/*****************************************************************************/ -int g_memcmp(void* s1, void* s2, int len) -{ - return memcmp(s1, s2, 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; -} - -/*****************************************************************************/ -/* 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; - lock.l_whence = SEEK_SET; - lock.l_start = start; - lock.l_len = len; - if (fcntl(fd, F_SETLK, &lock) == -1) - return 0; - return 1; -#endif -} - -/*****************************************************************************/ -int g_strlen(char* text) -{ - return strlen(text); -} - -/*****************************************************************************/ -char* g_strcpy(char* dest, char* src) -{ - return strcpy(dest, src); -} - -/*****************************************************************************/ -char* g_strncpy(char* dest, char* src, int len) -{ - char* rv; - - rv = strncpy(dest, src, len); - dest[len] = 0; - return rv; -} - -/*****************************************************************************/ -char* g_strcat(char* dest, char* src) -{ - return strcat(dest, src); -} - -/*****************************************************************************/ -char* g_strdup(char* in) -{ - int len; - char* p; - - if (in == 0) - return 0; - len = g_strlen(in); - p = (char*)g_malloc(len + 1, 0); - g_strcpy(p, in); - return p; -} - -/*****************************************************************************/ -int g_load_library(char* in) -{ - return (int)dlopen(in, RTLD_LOCAL | RTLD_LAZY); -} - -/*****************************************************************************/ -int g_free_library(int lib) -{ - if (lib == 0) - return 0; - return dlclose((void*)lib); -} - -/*****************************************************************************/ -/* returns NULL if not found */ -void* g_get_proc_address(int lib, char* name) -{ - if (lib == 0) - return 0; - return dlsym((void*)lib, name); -} diff --git a/vnc/parse.h b/vnc/parse.h deleted file mode 100644 index 477f35ab..00000000 --- a/vnc/parse.h +++ /dev/null @@ -1,299 +0,0 @@ -/* - rdesktop: A Remote Desktop Protocol client. - Parsing primitives - Copyright (C) Matthew Chapman 1999-2002 - - 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. -*/ - -/* modified for xrdp */ -/* this is a super fast stream method, you bet */ - -#if defined L_ENDIAN -#elif defined B_ENDIAN -#else -#error Unknown endianness. -#endif - -/* parser state */ -struct stream -{ - char* p; - char* end; - char* data; - int size; - /* offsets of various headers */ - char* iso_hdr; - char* mcs_hdr; - char* sec_hdr; - char* rdp_hdr; - char* channel_hdr; - char* next_packet; -}; - -/******************************************************************************/ -#define s_check(s) (s->p <= s->end) - -/******************************************************************************/ -#define s_check_rem(s, n) (s->p + n <= s->end) - -/******************************************************************************/ -#define s_check_end(s) (s->p == s->end) - -/******************************************************************************/ -#define make_stream(s) \ -{ \ - s = (struct stream*)g_malloc(sizeof(struct stream), 1); \ -} - -/******************************************************************************/ -#define init_stream(s, v) \ -{ \ - if (v > s->size) \ - { \ - g_free(s->data); \ - s->data = (char*)g_malloc(v, 0); \ - } \ - s->p = s->data; \ - s->end = s->data; \ - s->size = v; \ - s->next_packet = 0; \ -} - -/******************************************************************************/ -#define free_stream(s) \ -{ \ - if (s != 0) \ - g_free(s->data); \ - g_free(s); \ -} \ - -/******************************************************************************/ -#define s_push_layer(s, h, n) \ -{ \ - s->h = s->p; \ - s->p += n; \ -} - -/******************************************************************************/ -#define s_pop_layer(s, h) \ -{ \ - s->p = s->h; \ -} - -/******************************************************************************/ -#define s_mark_end(s) \ -{ \ - s->end = s->p; \ -} - -/******************************************************************************/ -#define in_uint8(s, v) \ -{ \ - v = *((unsigned char*)(s->p)); \ - s->p++; \ -} - -/******************************************************************************/ -#if defined B_ENDIAN || defined NEED_ALIGN -#define in_sint16_le(s, v) \ -{ \ - v = (signed short) \ - ( \ - (*((unsigned char*)(s->p + 0)) << 0) | \ - (*((unsigned char*)(s->p + 1)) << 8) \ - ); \ - s->p += 2; \ -} -#else -#define in_sint16_le(s, v) \ -{ \ - v = *((signed short*)(s->p)); \ - s->p += 2; \ -} -#endif - -/******************************************************************************/ -#if defined B_ENDIAN || defined NEED_ALIGN -#define in_uint16_le(s, v) \ -{ \ - v = (unsigned short) \ - ( \ - (*((unsigned char*)(s->p + 0)) << 0) | \ - (*((unsigned char*)(s->p + 1)) << 8) \ - ); \ - s->p += 2; \ -} -#else -#define in_uint16_le(s, v) \ -{ \ - v = *((unsigned short*)(s->p)); \ - s->p += 2; \ -} -#endif - -/******************************************************************************/ -#define in_uint16_be(s, v) \ -{ \ - v = *((unsigned char*)(s->p)); \ - s->p++; \ - v = v << 8; \ - v = v | *((unsigned char*)(s->p)); \ - s->p++; \ -} - -/******************************************************************************/ -#if defined B_ENDIAN || defined NEED_ALIGN -#define in_uint32_le(s, v) \ -{ \ - v = (unsigned long) \ - ( \ - (*((unsigned char*)(s->p + 0)) << 0) | \ - (*((unsigned char*)(s->p + 1)) << 8) | \ - (*((unsigned char*)(s->p + 2)) << 16) | \ - (*((unsigned char*)(s->p + 3)) << 24) \ - ); \ - s->p += 4; \ -} -#else -#define in_uint32_le(s, v) \ -{ \ - v = *((unsigned long*)(s->p)); \ - s->p += 4; \ -} -#endif - -/******************************************************************************/ -#define in_uint32_be(s, v) \ -{ \ - v = *((unsigned char*)(s->p)); \ - s->p++; \ - v = v << 8; \ - v = v | *((unsigned char*)(s->p)); \ - s->p++; \ - v = v << 8; \ - v = v | *((unsigned char*)(s->p)); \ - s->p++; \ - v = v << 8; \ - v = v | *((unsigned char*)(s->p)); \ - s->p++; \ -} - -/******************************************************************************/ -#define out_uint8(s, v) \ -{ \ - *(s->p) = (unsigned char)(v); \ - s->p++; \ -} - -/******************************************************************************/ -#if defined B_ENDIAN || defined NEED_ALIGN -#define out_uint16_le(s, v) \ -{ \ - *(s->p) = (unsigned char)(v); \ - s->p++; \ - *(s->p) = (unsigned char)((v) >> 8); \ - s->p++; \ -} -#else -#define out_uint16_le(s, v) \ -{ \ - *((unsigned short*)(s->p)) = (unsigned short)(v); \ - s->p += 2; \ -} -#endif - -/******************************************************************************/ -#define out_uint16_be(s, v) \ -{ \ - *(s->p) = (unsigned char)((v) >> 8); \ - s->p++; \ - *(s->p) = (unsigned char)(v); \ - s->p++; \ -} - -/******************************************************************************/ -#if defined B_ENDIAN || defined NEED_ALIGN -#define out_uint32_le(s, v) \ -{ \ - *(s->p) = (unsigned char)(v); \ - s->p++; \ - *(s->p) = (unsigned char)((v) >> 8); \ - s->p++; \ - *(s->p) = (unsigned char)((v) >> 16); \ - s->p++; \ - *(s->p) = (unsigned char)((v) >> 24); \ - s->p++; \ -} -#else -#define out_uint32_le(s, v) \ -{ \ - *((unsigned long*)(s->p)) = (v); \ - s->p += 4; \ -} -#endif - -/******************************************************************************/ -#define out_uint32_be(s, v) \ -{ \ - *(s->p) = (unsigned char)((v) >> 24); \ - s->p++; \ - *(s->p) = (unsigned char)((v) >> 16); \ - s->p++; \ - *(s->p) = (unsigned char)((v) >> 8); \ - s->p++; \ - *(s->p) = (unsigned char)(v); \ - s->p++; \ -} - -/******************************************************************************/ -#define in_uint8p(s, v, n) \ -{ \ - v = s->p; \ - s->p += n; \ -} - -/******************************************************************************/ -#define in_uint8a(s, v, n) \ -{ \ - g_memcpy(v, s->p, n); \ - s->p += n; \ -} - -/******************************************************************************/ -#define in_uint8s(s, n) \ -{ \ - s->p += n; \ -} - -/******************************************************************************/ -#define out_uint8p(s, v, n) \ -{ \ - g_memcpy(s->p, v, n); \ - s->p += n; \ -} - -/******************************************************************************/ -#define out_uint8a(s, v, n) \ -{ \ - out_uint8p(s, v, n); \ -} - -/******************************************************************************/ -#define out_uint8s(s, n) \ -{ \ - g_memset(s->p, 0, n); \ - s->p += n; \ -} diff --git a/vnc/vnc.c b/vnc/vnc.c index dffe0891..d036b278 100644 --- a/vnc/vnc.c +++ b/vnc/vnc.c @@ -22,23 +22,26 @@ #include "vnc.h" +const char* vnc_start_command = +"su %s -c \"sh ../vnc/startvnc.sh :%d %d %d %d\""; +const char* vnc_stop_command = +""; + /******************************************************************************/ -int lib_mod_event(int handle, int msg, int param1, int param2) +int lib_mod_event(struct vnc* v, int msg, int param1, int param2) { - struct vnc* v; struct stream* s; int key; make_stream(s); - v = (struct vnc*)handle; - if (msg >= 15 && msg <= 16) + if (msg >= 15 && msg <= 16) /* key events */ { key = 0; - if (param2 == 0xffff) + if (param2 == 0xffff) /* ascii char */ { key = param1; } - else + else /* non ascii key event */ { switch (param1) { @@ -90,7 +93,7 @@ int lib_mod_event(int handle, int msg, int param1, int param2) } } } - else if (msg >= 100 && msg <= 110) + else if (msg >= 100 && msg <= 110) /* mouse events */ { switch (msg) { @@ -289,9 +292,9 @@ int lib_framebuffer_update(struct vnc* v) free_stream(s); return 1; } - v->server_begin_update((int)v); - v->server_paint_rect((int)v, x, y, cx, cy, data); - v->server_end_update((int)v); + v->server_begin_update(v); + v->server_paint_rect(v, x, y, cx, cy, data); + v->server_end_update(v); g_free(data); } else if (encoding == 1) /* copy rect */ @@ -304,9 +307,9 @@ int lib_framebuffer_update(struct vnc* v) } in_uint16_be(s, srcx); in_uint16_be(s, srcy); - v->server_begin_update((int)v); - v->server_screen_blt((int)v, x, y, cx, cy, srcx, srcy); - v->server_end_update((int)v); + v->server_begin_update(v); + v->server_screen_blt(v, x, y, cx, cy, srcx, srcy); + v->server_end_update(v); } else if (encoding == 0xffffff11) /* cursor */ { @@ -336,7 +339,7 @@ int lib_framebuffer_update(struct vnc* v) } } } - v->server_set_cursor((int)v, x, y, cursor_data, cursor_mask); + v->server_set_cursor(v, x, y, cursor_data, cursor_mask); } } /* FrambufferUpdateRequest */ @@ -418,20 +421,18 @@ int lib_palette_update(struct vnc* v) b = b >> 8; v->palette[first_color + i] = (r << 16) | (g << 8) | b; } - v->server_begin_update((int)v); - v->server_palette((int)v, v->palette); - v->server_end_update((int)v); + v->server_begin_update(v); + v->server_palette(v, v->palette); + v->server_end_update(v); free_stream(s); return 0; } /******************************************************************************/ -int lib_mod_signal(int handle) +int lib_mod_signal(struct vnc* v) { - struct vnc* v; char type; - v = (struct vnc*)handle; if (g_tcp_force_recv(v->sck, &type, 1) != 0) { return 1; @@ -465,14 +466,11 @@ int lib_mod_signal(int handle) } /******************************************************************************/ -int lib_mod_start(int handle, int w, int h, int bpp) +int lib_mod_start(struct vnc* v, int w, int h, int bpp) { - struct vnc* v; - - v = (struct vnc*)handle; - v->server_begin_update(handle); - v->server_fill_rect(handle, 0, 0, w, h, 0); - v->server_end_update(handle); + v->server_begin_update(v); + v->server_fill_rect(v, 0, 0, w, h, 0); + v->server_end_update(v); v->server_width = w; v->server_height = h; v->server_bpp = bpp; @@ -480,22 +478,60 @@ int lib_mod_start(int handle, int w, int h, int bpp) } /******************************************************************************/ -int lib_mod_connect(int handle, char* ip, char* port, - char* username, char* password) +/* + return error + 1 - authentation failed + 2 - authentation failed + 3 - server name length received from server too long + 4 - server and client bpp do not match + 5 - no more available X desktops when spawning a new session + 6 - no ip +*/ +int lib_mod_connect(struct vnc* v) { char cursor_data[32 * (32 * 3)]; char cursor_mask[32 * (32 / 8)]; - struct vnc* v; + char text[256]; + char con_port[256]; struct stream* s; struct stream* pixel_format; int error; int i; + int check_sec_result; + check_sec_result = 1; + if (g_strcmp(v->ip, "") == 0) + { + return 6; + } + if (g_strcmp(v->port, "-1") == 0) + { + i = 10; + g_sprintf(text, vnc_start_command, v->username, i, v->server_bpp, + v->server_width, v->server_height); + error = g_system(text); + while (error != 0 && i < 100) + { + i++; + g_sprintf(text, vnc_start_command, v->username, i, v->server_bpp, + v->server_width, v->server_height); + error = g_system(text); + } + if (error != 0) + { + return 5; + } + g_sprintf(con_port, "%d", 5900 + i); + v->vnc_desktop = i; + } + else + { + g_sprintf(con_port, "%s", v->port); + } make_stream(s); make_stream(pixel_format); - v = (struct vnc*)handle; v->sck = g_tcp_socket(); - error = g_tcp_connect(v->sck, ip, port); + error = g_tcp_connect(v->sck, v->ip, con_port); if (error == 0) { g_tcp_set_non_blocking(v->sck); @@ -507,24 +543,32 @@ int lib_mod_connect(int handle, char* ip, char* port, init_stream(s, 8192); g_tcp_force_recv(v->sck, s->data, 4); in_uint32_be(s, i); - if (i == 2) /* dec the password and the server random */ + if (i == 1) /* none */ + { + check_sec_result = 0; + } + else if (i == 2) /* dec the password and the server random */ { init_stream(s, 8192); g_tcp_force_recv(v->sck, s->data, 16); - rfbEncryptBytes((unsigned char*)s->data, password); + rfbEncryptBytes((unsigned char*)s->data, v->password); g_tcp_force_send(v->sck, s->data, 16); } else + { error = 1; + } } - if (error == 0) + if (error == 0 && check_sec_result) { /* sec result */ init_stream(s, 8192); g_tcp_force_recv(v->sck, s->data, 4); in_uint32_be(s, i); if (i != 0) + { error = 2; + } } if (error == 0) { @@ -541,7 +585,9 @@ int lib_mod_connect(int handle, char* ip, char* port, g_tcp_force_recv(v->sck, s->data, 4); /* name len */ in_uint32_be(s, i); if (i > 255 || i < 0) + { error = 3; + } else { g_tcp_force_recv(v->sck, v->mod_name, i); @@ -595,9 +641,11 @@ int lib_mod_connect(int handle, char* ip, char* port, } if (error == 0) { - v->server_error_popup((int)v, "hi", "Hi"); + v->server_error_popup(v, "hi", "Hi"); if (v->server_bpp != v->mod_bpp) + { error = 4; + } } /* set almost null cursor */ g_memset(cursor_data, 0, 32 * (32 * 3)); @@ -605,20 +653,18 @@ int lib_mod_connect(int handle, char* ip, char* port, g_memset(cursor_data + (32 * (32 * 3) - 2 * 32 * 3), 0xff, 9); g_memset(cursor_data + (32 * (32 * 3) - 3 * 32 * 3), 0xff, 9); g_memset(cursor_mask, 0xff, 32 * (32 / 8)); - v->server_set_cursor((int)v, 0, 0, cursor_data, cursor_mask); + v->server_set_cursor(v, 0, 0, cursor_data, cursor_mask); free_stream(s); free_stream(pixel_format); return error; } /******************************************************************************/ -int lib_mod_invalidate(int handle, int x, int y, int cx, int cy) +int lib_mod_invalidate(struct vnc* v, int x, int y, int cx, int cy) { - struct vnc* v; struct stream* s; make_stream(s); - v = (struct vnc*)handle; /* FrambufferUpdateRequest */ init_stream(s, 8192); out_uint8(s, 3); @@ -632,6 +678,33 @@ int lib_mod_invalidate(int handle, int x, int y, int cx, int cy) return 0; } +/******************************************************************************/ +int lib_mod_end(struct vnc* v) +{ + char text[256]; + + if (v->vnc_desktop != 0) + { + g_sprintf(text, vnc_stop_command, v->username, v->vnc_desktop); + g_system(text); + } + return 0; +} + +/******************************************************************************/ +int lib_mod_set_param(struct vnc* v, char* name, char* value) +{ + if (g_strcmp(name, "username") == 0) + g_strncpy(v->username, value, 255); + else if (g_strcmp(name, "password") == 0) + g_strncpy(v->password, value, 255); + else if (g_strcmp(name, "ip") == 0) + g_strncpy(v->ip, value, 255); + else if (g_strcmp(name, "port") == 0) + g_strncpy(v->port, value, 255); + return 0; +} + /******************************************************************************/ int mod_init() { @@ -646,17 +719,16 @@ int mod_init() v->mod_event = lib_mod_event; v->mod_signal = lib_mod_signal; v->mod_invalidate = lib_mod_invalidate; + v->mod_end = lib_mod_end; + v->mod_set_param = lib_mod_set_param; return (int)v; } /******************************************************************************/ -int mod_exit(int handle) +int mod_exit(struct vnc* v) { - struct vnc* v; - - if (handle == 0) + if (v == 0) return 0; - v = (struct vnc*)handle; g_tcp_close(v->sck); g_free(v); return 0; diff --git a/vnc/vnc.h b/vnc/vnc.h index 81079b73..c2963011 100644 --- a/vnc/vnc.h +++ b/vnc/vnc.h @@ -20,120 +20,37 @@ */ -/* check endianess */ -#if __BYTE_ORDER == __LITTLE_ENDIAN -#define L_ENDIAN -#elif __BYTE_ORDER == __BIG_ENDIAN -#define B_ENDIAN -#endif -/* check if we need to align data */ -#if defined(__sparc__) || defined(__alpha__) || defined(__hppa__) || \ - defined(__AIX__) || defined(__PPC__) || defined(__mips__) || \ - defined(__ia64__) -#define NEED_ALIGN -#endif /* include other h files */ +#include "arch.h" #include "parse.h" - -#ifdef _WIN32 -#define THREAD_RV unsigned long -#define THREAD_CC __stdcall -#else -#define THREAD_RV void* -#define THREAD_CC -#endif +#include "os_calls.h" void rfbEncryptBytes(unsigned char *bytes, char *passwd); -/* os_calls.c */ -int g_init_system(void); -int g_exit_system(void); -void g_printf(char *format, ...); -void g_hexdump(char* p, int len); -void* g_malloc(int size, int zero); -void* g_malloc1(int size, int zero); -void g_free(void* ptr); -void g_free1(void* ptr); -void g_memset(void* ptr, int val, int size); -void g_memcpy(void* d_ptr, const void* s_ptr, int size); -int g_getchar(void); -int g_tcp_socket(void); -int g_tcp_local_socket(void); -void g_tcp_close(int sck); -int g_tcp_connect(int sck, char* address, char* port); -int g_tcp_force_send(int sck, char* data, int len); -int g_tcp_force_recv(int sck, char* data, int len); -int g_tcp_set_non_blocking(int sck); -int g_tcp_bind(int sck, char* port); -int g_tcp_local_bind(int sck, char* port); -int g_tcp_listen(int sck); -int g_tcp_accept(int sck); -int g_tcp_recv(int sck, void* ptr, int len, int flags); -int g_tcp_send(int sck, void* ptr, int len, int flags); -int g_tcp_last_error_would_block(int sck); -int g_tcp_select(int sck1, int sck2); -int g_is_term(void); -void g_set_term(int in_val); -void g_sleep(int msecs); -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); -void g_rc4_crypt(void* rc4_info, char* data, int len); -void* g_sha1_info_create(void); -void g_sha1_info_delete(void* sha1_info); -void g_sha1_clear(void* sha1_info); -void g_sha1_transform(void* sha1_info, char* data, int len); -void g_sha1_complete(void* sha1_info, char* data); -void* g_md5_info_create(void); -void g_md5_info_delete(void* md5_info); -void g_md5_clear(void* md5_info); -void g_md5_transform(void* md5_info, char* data, int len); -void g_md5_complete(void* md5_info, char* data); -int g_mod_exp(char* out, char* in, char* mod, char* exp); -void g_random(char* data, int len); -int g_abs(int i); -int g_memcmp(void* s1, void* s2, int len); -int g_file_open(char* file_name); -int g_file_close(int fd); -int g_file_read(int fd, char* ptr, int len); -int g_file_write(int fd, char* ptr, int len); -int g_file_seek(int fd, int offset); -int g_file_lock(int fd, int start, int len); -int g_strlen(char* text); -char* g_strcpy(char* dest, char* src); -char* g_strncpy(char* dest, char* src, int len); -char* g_strcat(char* dest, char* src); -char* g_strdup(char* in); -int g_load_library(char* in); -int g_free_library(int lib); -void* g_get_proc_address(int lib, char* name); - -#define COLOR16(r, g, b) ((((r) >> 3) << 11) | (((g) >> 2) << 5) | ((b) >> 3)) - struct vnc { int size; /* size of this struct */ /* client functions */ - int (*mod_start)(int handle, int w, int h, int bpp); - int (*mod_connect)(int handle, char* ip, char* port, - char* username, char* password); - int (*mod_event)(int handle, int msg, int param1, int param2); - int (*mod_signal)(int handle); - int (*mod_invalidate)(int handle, int x, int y, int cx, int cy); - int d1[95]; + 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_signal)(struct vnc* v); + int (*mod_invalidate)(struct vnc* v, int x, int y, int cx, int cy); + int (*mod_end)(struct vnc* v); + int (*mod_set_param)(struct vnc* v, char* name, char* value); + int d1[93]; /* server functions */ - int (*server_begin_update)(int handle); - int (*server_end_update)(int handle); - int (*server_fill_rect)(int handle, int x, int y, int cx, int cy, + int (*server_begin_update)(struct vnc* v); + int (*server_end_update)(struct vnc* v); + int (*server_fill_rect)(struct vnc* v, int x, int y, int cx, int cy, int color); - int (*server_screen_blt)(int handle, int x, int y, int cx, int cy, + int (*server_screen_blt)(struct vnc* v, int x, int y, int cx, int cy, int srcx, int srcy); - int (*server_paint_rect)(int handle, int x, int y, int cx, int cy, + int (*server_paint_rect)(struct vnc* v, int x, int y, int cx, int cy, char* data); - int (*server_set_cursor)(int handle, int x, int y, char* data, char* mask); - int (*server_palette)(int handle, int* palette); - int (*server_error_popup)(int handle, char* error, char* caption); + int (*server_set_cursor)(struct vnc* v, int x, int y, char* data, char* mask); + int (*server_palette)(struct vnc* v, int* palette); + int (*server_error_popup)(struct vnc* v, char* error, char* caption); int d2[92]; /* common */ int handle; /* pointer to self as int */ @@ -150,4 +67,9 @@ struct vnc char mod_name[256]; int mod_mouse_state; int palette[256]; + int vnc_desktop; + char username[256]; + char password[256]; + char ip[256]; + char port[256]; };