summaryrefslogtreecommitdiffstats
path: root/xorg/server/module/rdpClientCon.c
diff options
context:
space:
mode:
Diffstat (limited to 'xorg/server/module/rdpClientCon.c')
-rw-r--r--xorg/server/module/rdpClientCon.c2283
1 files changed, 0 insertions, 2283 deletions
diff --git a/xorg/server/module/rdpClientCon.c b/xorg/server/module/rdpClientCon.c
deleted file mode 100644
index 21df291f..00000000
--- a/xorg/server/module/rdpClientCon.c
+++ /dev/null
@@ -1,2283 +0,0 @@
-/*
-Copyright 2005-2014 Jay Sorg
-
-Permission to use, copy, modify, distribute, and sell this software and its
-documentation for any purpose is hereby granted without fee, provided that
-the above copyright notice appear in all copies and that both that
-copyright notice and this permission notice appear in supporting
-documentation.
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
-AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-Client connection to xrdp
-
-*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <signal.h>
-#include <sys/types.h>
-#include <sys/ipc.h>
-#include <sys/shm.h>
-
-/* this should be before all X11 .h files */
-#include <xorg-server.h>
-#include <xorgVersion.h>
-
-/* all driver need this */
-#include <xf86.h>
-#include <xf86_OSproc.h>
-
-#include "rdp.h"
-#include "rdpDraw.h"
-#include "rdpClientCon.h"
-#include "rdpMisc.h"
-#include "rdpInput.h"
-#include "rdpReg.h"
-#include "rdpCapture.h"
-
-#define LOG_LEVEL 1
-#define LLOGLN(_level, _args) \
- do { if (_level < LOG_LEVEL) { ErrorF _args ; ErrorF("\n"); } } while (0)
-
-#define LTOUI32(_in) ((unsigned int)(_in))
-
-#define USE_MAX_OS_BYTES 1
-#define MAX_OS_BYTES (16 * 1024 * 1024)
-
-/*
-0 GXclear, 0
-1 GXnor, DPon
-2 GXandInverted, DPna
-3 GXcopyInverted, Pn
-4 GXandReverse, PDna
-5 GXinvert, Dn
-6 GXxor, DPx
-7 GXnand, DPan
-8 GXand, DPa
-9 GXequiv, DPxn
-a GXnoop, D
-b GXorInverted, DPno
-c GXcopy, P
-d GXorReverse, PDno
-e GXor, DPo
-f GXset 1
-*/
-
-static int g_rdp_opcodes[16] =
-{
- 0x00, /* GXclear 0x0 0 */
- 0x88, /* GXand 0x1 src AND dst */
- 0x44, /* GXandReverse 0x2 src AND NOT dst */
- 0xcc, /* GXcopy 0x3 src */
- 0x22, /* GXandInverted 0x4 NOT src AND dst */
- 0xaa, /* GXnoop 0x5 dst */
- 0x66, /* GXxor 0x6 src XOR dst */
- 0xee, /* GXor 0x7 src OR dst */
- 0x11, /* GXnor 0x8 NOT src AND NOT dst */
- 0x99, /* GXequiv 0x9 NOT src XOR dst */
- 0x55, /* GXinvert 0xa NOT dst */
- 0xdd, /* GXorReverse 0xb src OR NOT dst */
- 0x33, /* GXcopyInverted 0xc NOT src */
- 0xbb, /* GXorInverted 0xd NOT src OR dst */
- 0x77, /* GXnand 0xe NOT src OR NOT dst */
- 0xff /* GXset 0xf 1 */
-};
-
-static int
-rdpClientConDisconnect(rdpPtr dev, rdpClientCon *clientCon);
-
-/******************************************************************************/
-static int
-rdpClientConGotConnection(ScreenPtr pScreen, rdpPtr dev)
-{
- rdpClientCon *clientCon;
- int new_sck;
-
- LLOGLN(0, ("rdpClientConGotConnection:"));
- clientCon = (rdpClientCon *) g_malloc(sizeof(rdpClientCon), 1);
- clientCon->dev = dev;
- dev->do_dirty_ons = 1;
-
- make_stream(clientCon->in_s);
- init_stream(clientCon->in_s, 8192);
- make_stream(clientCon->out_s);
- init_stream(clientCon->out_s, 8192 * 4 + 100);
-
- new_sck = g_sck_accept(dev->listen_sck);
- if (new_sck == -1)
- {
- LLOGLN(0, ("rdpClientConGotConnection: g_sck_accept failed"));
- }
- else
- {
- LLOGLN(0, ("rdpClientConGotConnection: g_sck_accept ok new_sck %d",
- new_sck));
- clientCon->sck = new_sck;
- g_sck_set_non_blocking(clientCon->sck);
- g_sck_tcp_set_no_delay(clientCon->sck); /* only works if TCP */
- clientCon->connected = TRUE;
- clientCon->sckClosed = FALSE;
- clientCon->begin = FALSE;
- dev->conNumber++;
- clientCon->conNumber = dev->conNumber;
- AddEnabledDevice(clientCon->sck);
- }
-
-#if 0
- if (dev->clientConTail != NULL)
- {
- rdpClientConDisconnect(dev, dev->clientConTail);
- dev->clientConHead = NULL;
- dev->clientConTail = NULL;
- }
-#endif
-
- if (dev->clientConTail == NULL)
- {
- LLOGLN(0, ("rdpClientConGotConnection: adding only clientCon"));
- dev->clientConHead = clientCon;
- dev->clientConTail = clientCon;
- }
- else
- {
- LLOGLN(0, ("rdpClientConGotConnection: adding clientCon"));
- dev->clientConTail->next = clientCon;
- dev->clientConTail = clientCon;
- }
-
- clientCon->dirtyRegion = rdpRegionCreate(NullBox, 0);
- clientCon->shmRegion = rdpRegionCreate(NullBox, 0);
-
- return 0;
-}
-
-/******************************************************************************/
-static CARD32
-rdpDeferredDisconnectCallback(OsTimerPtr timer, CARD32 now, pointer arg)
-{
- CARD32 lnow_ms;
- rdpPtr dev;
-
- dev = (rdpPtr) arg;
- LLOGLN(10, ("rdpDeferredDisconnectCallback"));
- if (dev->clientConHead != NULL)
- {
- /* this should not happen */
- LLOGLN(0, ("rdpDeferredDisconnectCallback: connected"));
- if (dev->disconnectTimer != NULL)
- {
- LLOGLN(0, ("rdpDeferredDisconnectCallback: canceling g_dis_timer"));
- TimerCancel(dev->disconnectTimer);
- TimerFree(dev->disconnectTimer);
- dev->disconnectTimer = NULL;
- }
- dev->disconnect_scheduled = FALSE;
- return 0;
- }
- else
- {
- LLOGLN(10, ("rdpDeferredDisconnectCallback: not connected"));
- }
- lnow_ms = GetTimeInMillis();
- if (lnow_ms - dev->disconnect_time_ms > dev->disconnect_timeout_s * 1000)
- {
- LLOGLN(0, ("rdpDeferredDisconnectCallback: exit X11rdp"));
- kill(getpid(), SIGTERM);
- return 0;
- }
- dev->disconnectTimer = TimerSet(dev->disconnectTimer, 0, 1000 * 10,
- rdpDeferredDisconnectCallback, dev);
- return 0;
-}
-
-/*****************************************************************************/
-static int
-rdpClientConDisconnect(rdpPtr dev, rdpClientCon *clientCon)
-{
- int index;
- rdpClientCon *pcli;
- rdpClientCon *plcli;
-
- LLOGLN(0, ("rdpClientConDisconnect:"));
- if (dev->do_kill_disconnected)
- {
- if (dev->disconnect_scheduled == FALSE)
- {
- LLOGLN(0, ("rdpClientConDisconnect: starting g_dis_timer"));
- dev->disconnectTimer = TimerSet(dev->disconnectTimer, 0, 1000 * 10,
- rdpDeferredDisconnectCallback, dev);
- dev->disconnect_scheduled = TRUE;
- }
- dev->disconnect_time_ms = GetTimeInMillis();
- }
-
- RemoveEnabledDevice(clientCon->sck);
- g_sck_close(clientCon->sck);
- if (clientCon->maxOsBitmaps > 0)
- {
- for (index = 0; index < clientCon->maxOsBitmaps; index++)
- {
- if (clientCon->osBitmaps[index].used)
- {
- if (clientCon->osBitmaps[index].priv != NULL)
- {
- clientCon->osBitmaps[index].priv->status = 0;
- }
- }
- }
- }
- g_free(clientCon->osBitmaps);
-
- plcli = NULL;
- pcli = dev->clientConHead;
- while (pcli != NULL)
- {
- if (pcli == clientCon)
- {
- if (plcli == NULL)
- {
- /* removing first item */
- dev->clientConHead = pcli->next;
- if (dev->clientConHead == NULL)
- {
- /* removed only */
- dev->clientConTail = NULL;
- }
- }
- else
- {
- plcli->next = pcli->next;
- if (pcli == dev->clientConTail)
- {
- /* removed last */
- dev->clientConTail = plcli;
- }
- }
- LLOGLN(0, ("rdpClientConDisconnect: clientCon removed from "
- "dev list"));
- break;
- }
- plcli = pcli;
- pcli = pcli->next;
- }
- rdpRegionDestroy(clientCon->dirtyRegion);
- rdpRegionDestroy(clientCon->shmRegion);
- if (clientCon->updateTimer != NULL)
- {
- TimerCancel(clientCon->updateTimer);
- TimerFree(clientCon->updateTimer);
- }
- g_free(clientCon);
- return 0;
-}
-
-/*****************************************************************************/
-/* returns error */
-static int
-rdpClientConSend(rdpPtr dev, rdpClientCon *clientCon, char *data, int len)
-{
- int sent;
-
- LLOGLN(10, ("rdpClientConSend - sending %d bytes", len));
-
- if (clientCon->sckClosed)
- {
- return 1;
- }
-
- while (len > 0)
- {
- sent = g_sck_send(clientCon->sck, data, len, 0);
-
- if (sent == -1)
- {
- if (g_sck_last_error_would_block(clientCon->sck))
- {
- g_sleep(1);
- }
- else
- {
- LLOGLN(0, ("rdpClientConSend: g_tcp_send failed(returned -1)"));
- rdpClientConDisconnect(dev, clientCon);
- return 1;
- }
- }
- else if (sent == 0)
- {
- LLOGLN(0, ("rdpClientConSend: g_tcp_send failed(returned zero)"));
- rdpClientConDisconnect(dev, clientCon);
- return 1;
- }
- else
- {
- data += sent;
- len -= sent;
- }
- }
-
- return 0;
-}
-
-/******************************************************************************/
-static int
-rdpClientConSendMsg(rdpPtr dev, rdpClientCon *clientCon)
-{
- int len;
- int rv;
- struct stream *s;
-
- rv = 1;
- s = clientCon->out_s;
- if (s != NULL)
- {
- len = (int) (s->end - s->data);
-
- if (len > s->size)
- {
- LLOGLN(0, ("rdpClientConSendMsg: overrun error len %d count %d",
- len, clientCon->count));
- }
-
- s_pop_layer(s, iso_hdr);
- out_uint16_le(s, 3);
- out_uint16_le(s, clientCon->count);
- out_uint32_le(s, len - 8);
- rv = rdpClientConSend(dev, clientCon, s->data, len);
- }
-
- if (rv != 0)
- {
- LLOGLN(0, ("rdpClientConSendMsg: error in rdpup_send_msg"));
- }
-
- return rv;
-}
-
-/******************************************************************************/
-static int
-rdpClientConSendPending(rdpPtr dev, rdpClientCon *clientCon)
-{
- int rv;
-
- rv = 0;
- if (clientCon->connected && clientCon->begin)
- {
- out_uint16_le(clientCon->out_s, 2); /* XR_SERVER_END_UPDATE */
- out_uint16_le(clientCon->out_s, 4); /* size */
- clientCon->count++;
- s_mark_end(clientCon->out_s);
- if (rdpClientConSendMsg(dev, clientCon) != 0)
- {
- LLOGLN(0, ("rdpClientConSendPending: rdpClientConSendMsg failed"));
- rv = 1;
- }
- }
- clientCon->count = 0;
- clientCon->begin = FALSE;
- return rv;
-}
-
-/******************************************************************************/
-/* returns error */
-static int
-rdpClientConRecv(rdpPtr dev, rdpClientCon *clientCon, char *data, int len)
-{
- int rcvd;
-
- if (clientCon->sckClosed)
- {
- return 1;
- }
-
- while (len > 0)
- {
- rcvd = g_sck_recv(clientCon->sck, data, len, 0);
-
- if (rcvd == -1)
- {
- if (g_sck_last_error_would_block(clientCon->sck))
- {
- g_sleep(1);
- }
- else
- {
- LLOGLN(0, ("rdpClientConRecv: g_sck_recv failed(returned -1)"));
- rdpClientConDisconnect(dev, clientCon);
- return 1;
- }
- }
- else if (rcvd == 0)
- {
- LLOGLN(0, ("rdpClientConRecv: g_sck_recv failed(returned 0)"));
- rdpClientConDisconnect(dev, clientCon);
- return 1;
- }
- else
- {
- data += rcvd;
- len -= rcvd;
- }
- }
-
- return 0;
-}
-
-/******************************************************************************/
-static int
-rdpClientConRecvMsg(rdpPtr dev, rdpClientCon *clientCon)
-{
- int len;
- int rv;
- struct stream *s;
-
- rv = 1;
-
- s = clientCon->in_s;
- if (s != 0)
- {
- init_stream(s, 4);
- rv = rdpClientConRecv(dev, clientCon, s->data, 4);
-
- if (rv == 0)
- {
- s->end = s->data + 4;
- in_uint32_le(s, len);
-
- if (len > 3)
- {
- init_stream(s, len);
- rv = rdpClientConRecv(dev, clientCon, s->data, len - 4);
- if (rv == 0)
- {
- s->end = s->data + len;
- }
- }
- }
- }
-
- if (rv != 0)
- {
- LLOGLN(0, ("rdpClientConRecvMsg: error"));
- }
-
- return rv;
-}
-
-/******************************************************************************/
-static int
-rdpClientConSendCaps(rdpPtr dev, rdpClientCon *clientCon)
-{
- struct stream *ls;
- int len;
- int rv;
- int cap_count;
- int cap_bytes;
-
- make_stream(ls);
- init_stream(ls, 8192);
- s_push_layer(ls, iso_hdr, 8);
-
- cap_count = 0;
- cap_bytes = 0;
-
-#if 0
- out_uint16_le(ls, 0);
- out_uint16_le(ls, 4);
- cap_count++;
- cap_bytes += 4;
-
- out_uint16_le(ls, 1);
- out_uint16_le(ls, 4);
- cap_count++;
- cap_bytes += 4;
-#endif
-
- s_mark_end(ls);
- len = (int)(ls->end - ls->data);
- s_pop_layer(ls, iso_hdr);
- out_uint16_le(ls, 2); /* caps */
- out_uint16_le(ls, cap_count); /* num caps */
- out_uint32_le(ls, cap_bytes); /* caps len after header */
-
- rv = rdpClientConSend(dev, clientCon, ls->data, len);
-
- if (rv != 0)
- {
- LLOGLN(0, ("rdpClientConSendCaps: rdpup_send failed"));
- }
-
- free_stream(ls);
- return rv;
-}
-
-/******************************************************************************/
-static int
-rdpClientConProcessMsgVersion(rdpPtr dev, rdpClientCon *clientCon,
- int param1, int param2, int param3, int param4)
-{
- LLOGLN(0, ("rdpClientConProcessMsgVersion: version %d %d %d %d",
- param1, param2, param3, param4));
-
- if ((param1 > 0) || (param2 > 0) || (param3 > 0) || (param4 > 0))
- {
- rdpClientConSendCaps(dev, clientCon);
- }
-
- return 0;
-}
-
-#define LALIGN(_num, _po2) ((_num + ((_po2) - 1)) & ~((_po2) - 1))
-
-/******************************************************************************/
-/*
- this from miScreenInit
- pScreen->mmWidth = (xsize * 254 + dpix * 5) / (dpix * 10);
- pScreen->mmHeight = (ysize * 254 + dpiy * 5) / (dpiy * 10);
-*/
-static int
-rdpClientConProcessScreenSizeMsg(rdpPtr dev, rdpClientCon *clientCon,
- int width, int height, int bpp)
-{
- RRScreenSizePtr pSize;
- int mmwidth;
- int mmheight;
- int bytes;
- Bool ok;
-
- LLOGLN(0, ("rdpClientConProcessScreenSizeMsg: set width %d height %d "
- "bpp %d", width, height, bpp));
- clientCon->rdp_width = width;
- clientCon->rdp_height = height;
- clientCon->rdp_bpp = bpp;
- clientCon->cap_width = width;
- clientCon->cap_height = height;
-
- if (bpp < 15)
- {
- clientCon->rdp_Bpp = 1;
- clientCon->rdp_Bpp_mask = 0xff;
- clientCon->rdp_format = PIXMAN_r3g3b2;
- }
- else if (bpp == 15)
- {
- clientCon->rdp_Bpp = 2;
- clientCon->rdp_Bpp_mask = 0x7fff;
- clientCon->rdp_format = XRDP_a1r5g5b5;
- }
- else if (bpp == 16)
- {
- clientCon->rdp_Bpp = 2;
- clientCon->rdp_Bpp_mask = 0xffff;
- clientCon->rdp_format = XRDP_r5g6b5;
- }
- else if (bpp > 16)
- {
- clientCon->rdp_Bpp = 4;
- clientCon->rdp_Bpp_mask = 0xffffff;
- clientCon->rdp_format = XRDP_a8r8g8b8;
- }
-
- if (clientCon->shmemptr != 0)
- {
- shmdt(clientCon->shmemptr);
- }
- bytes = clientCon->rdp_width * clientCon->rdp_height *
- clientCon->rdp_Bpp;
- clientCon->shmemid = shmget(IPC_PRIVATE, bytes, IPC_CREAT | 0777);
- clientCon->shmemptr = shmat(clientCon->shmemid, 0, 0);
- shmctl(clientCon->shmemid, IPC_RMID, NULL);
- LLOGLN(0, ("rdpClientConProcessScreenSizeMsg: shmemid %d shmemptr %p",
- clientCon->shmemid, clientCon->shmemptr));
- clientCon->shmem_lineBytes = clientCon->rdp_Bpp * clientCon->rdp_width;
-
- if (clientCon->shmRegion != 0)
- {
- rdpRegionDestroy(clientCon->shmRegion);
- }
- clientCon->shmRegion = rdpRegionCreate(NullBox, 0);
-
- mmwidth = PixelToMM(width);
- mmheight = PixelToMM(height);
-
- pSize = RRRegisterSize(dev->pScreen, width, height, mmwidth, mmheight);
- RRSetCurrentConfig(dev->pScreen, RR_Rotate_0, 0, pSize);
-
- if ((dev->width != width) || (dev->height != height))
- {
- ok = RRScreenSizeSet(dev->pScreen, width, height, mmwidth, mmheight);
- LLOGLN(0, ("rdpClientConProcessScreenSizeMsg: RRScreenSizeSet ok=[%d]", ok));
- }
-
- return 0;
-}
-
-/******************************************************************************/
-static int
-rdpClientConProcessMsgClientInput(rdpPtr dev, rdpClientCon *clientCon)
-{
- struct stream *s;
- int msg;
- int param1;
- int param2;
- int param3;
- int param4;
- int x;
- int y;
- int cx;
- int cy;
-
- s = clientCon->in_s;
- in_uint32_le(s, msg);
- in_uint32_le(s, param1);
- in_uint32_le(s, param2);
- in_uint32_le(s, param3);
- in_uint32_le(s, param4);
-
- LLOGLN(10, ("rdpClientConProcessMsgClientInput: msg %d param1 %d param2 %d "
- "param3 %d param4 %d", msg, param1, param2, param3, param4));
-
- if (msg < 100)
- {
- rdpInputKeyboardEvent(dev, msg, param1, param2, param3, param4);
- }
- else if (msg < 200)
- {
- rdpInputMouseEvent(dev, msg, param1, param2, param3, param4);
- }
- else if (msg == 200) /* invalidate */
- {
- x = (param1 >> 16) & 0xffff;
- y = param1 & 0xffff;
- cx = (param2 >> 16) & 0xffff;
- cy = param2 & 0xffff;
- LLOGLN(0, ("rdpClientConProcessMsgClientInput: invalidate x %d y %d "
- "cx %d cy %d", x, y, cx, cy));
- rdpClientConAddDirtyScreen(dev, clientCon, x, y, cx, cy);
- }
- else if (msg == 300) /* resize desktop */
- {
- rdpClientConProcessScreenSizeMsg(dev, clientCon, param1,
- param2, param3);
- }
- else if (msg == 301) /* version */
- {
- rdpClientConProcessMsgVersion(dev, clientCon,
- param1, param2, param3, param4);
- }
- else
- {
- LLOGLN(0, ("rdpClientConProcessMsgClientInput: unknown msg %d", msg));
- }
-
- return 0;
-}
-
-/******************************************************************************/
-static int
-rdpClientConProcessMsgClientInfo(rdpPtr dev, rdpClientCon *clientCon)
-{
- struct stream *s;
- int bytes;
- int i1;
-
- LLOGLN(0, ("rdpClientConProcessMsgClientInfo:"));
- s = clientCon->in_s;
- in_uint32_le(s, bytes);
- if (bytes > sizeof(clientCon->client_info))
- {
- bytes = sizeof(clientCon->client_info);
- }
- memcpy(&(clientCon->client_info), s->p - 4, bytes);
- clientCon->client_info.size = bytes;
-
- LLOGLN(0, (" got client info bytes %d", bytes));
- LLOGLN(0, (" jpeg support %d", clientCon->client_info.jpeg));
- i1 = clientCon->client_info.offscreen_support_level;
- LLOGLN(0, (" offscreen support %d", i1));
- i1 = clientCon->client_info.offscreen_cache_size;
- LLOGLN(0, (" offscreen size %d", i1));
- i1 = clientCon->client_info.offscreen_cache_entries;
- LLOGLN(0, (" offscreen entries %d", i1));
-
- if (clientCon->client_info.capture_format != 0)
- {
- clientCon->rdp_format = clientCon->client_info.capture_format;
- }
-
- if (clientCon->client_info.capture_code == 2) /* RFX */
- {
- LLOGLN(0, ("rdpClientConProcessMsgClientInfo: got RFX capture"));
- clientCon->cap_width = LALIGN(clientCon->rdp_width, 64);
- clientCon->cap_height = LALIGN(clientCon->rdp_height, 64);
- LLOGLN(0, (" cap_width %d cap_height %d",
- clientCon->cap_width, clientCon->cap_height));
- if (clientCon->shmemptr != 0)
- {
- shmdt(clientCon->shmemptr);
- }
- bytes = clientCon->cap_width * clientCon->cap_height *
- clientCon->rdp_Bpp;
- clientCon->shmemid = shmget(IPC_PRIVATE, bytes, IPC_CREAT | 0777);
- clientCon->shmemptr = shmat(clientCon->shmemid, 0, 0);
- shmctl(clientCon->shmemid, IPC_RMID, NULL);
- LLOGLN(0, ("rdpClientConProcessMsgClientInfo: shmemid %d shmemptr %p "
- "bytes %d", clientCon->shmemid, clientCon->shmemptr, bytes));
- clientCon->shmem_lineBytes = clientCon->rdp_Bpp * clientCon->cap_width;
- }
-
- if (clientCon->client_info.offscreen_support_level > 0)
- {
- if (clientCon->client_info.offscreen_cache_entries > 0)
- {
- clientCon->maxOsBitmaps = clientCon->client_info.offscreen_cache_entries;
- g_free(clientCon->osBitmaps);
- clientCon->osBitmaps = (struct rdpup_os_bitmap *)
- g_malloc(sizeof(struct rdpup_os_bitmap) * clientCon->maxOsBitmaps, 1);
- }
- }
-
- if (clientCon->client_info.orders[0x1b]) /* 27 NEG_GLYPH_INDEX_INDEX */
- {
- LLOGLN(0, (" client supports glyph cache but server disabled"));
- //clientCon->doGlyphCache = 1;
- }
- if (clientCon->client_info.order_flags_ex & 0x100)
- {
- clientCon->doComposite = 1;
- }
- if (clientCon->doGlyphCache)
- {
- LLOGLN(0, (" using glyph cache"));
- }
- if (clientCon->doComposite)
- {
- LLOGLN(0, (" using client composite"));
- }
- LLOGLN(10, ("order_flags_ex 0x%x", clientCon->client_info.order_flags_ex));
- if (clientCon->client_info.offscreen_cache_entries == 2000)
- {
- LLOGLN(0, (" client can do offscreen to offscreen blits"));
- clientCon->canDoPixToPix = 1;
- }
- else
- {
- LLOGLN(0, (" client can not do offscreen to offscreen blits"));
- clientCon->canDoPixToPix = 0;
- }
- if (clientCon->client_info.pointer_flags & 1)
- {
- LLOGLN(0, (" client can do new(color) cursor"));
- }
- else
- {
- LLOGLN(0, (" client can not do new(color) cursor"));
- }
- if (clientCon->client_info.monitorCount > 0)
- {
- LLOGLN(0, (" client can do multimon"));
- LLOGLN(0, (" client monitor data, monitorCount= %d", clientCon->client_info.monitorCount));
- clientCon->doMultimon = 1;
- }
- else
- {
- LLOGLN(0, (" client can not do multimon"));
- clientCon->doMultimon = 0;
- }
-
- //rdpLoadLayout(g_rdpScreen.client_info.keylayout);
-
- return 0;
-}
-
-/******************************************************************************/
-static int
-rdpClientConProcessMsgClientRegion(rdpPtr dev, rdpClientCon *clientCon)
-{
- struct stream *s;
- int flags;
- int x;
- int y;
- int cx;
- int cy;
- RegionRec reg;
- BoxRec box;
-
- LLOGLN(10, ("rdpClientConProcessMsgClientRegion:"));
- s = clientCon->in_s;
-
- in_uint32_le(s, flags);
- in_uint32_le(s, clientCon->rect_id_ack);
- in_uint32_le(s, x);
- in_uint32_le(s, y);
- in_uint32_le(s, cx);
- in_uint32_le(s, cy);
- LLOGLN(10, ("rdpClientConProcessMsgClientRegion: %d %d %d %d flags 0x%8.8x",
- x, y, cx, cy, flags));
- LLOGLN(10, ("rdpClientConProcessMsgClientRegion: rect_id %d rect_id_ack %d",
- clientCon->rect_id, clientCon->rect_id_ack));
-
- box.x1 = x;
- box.y1 = y;
- box.x2 = box.x1 + cx;
- box.y2 = box.y1 + cy;
-
- rdpRegionInit(&reg, &box, 0);
- LLOGLN(10, ("rdpClientConProcessMsgClientRegion: %d %d %d %d",
- box.x1, box.y1, box.x2, box.y2));
- rdpRegionSubtract(clientCon->shmRegion, clientCon->shmRegion, &reg);
- rdpRegionUninit(&reg);
-
- return 0;
-}
-
-/******************************************************************************/
-static int
-rdpClientConProcessMsgClientRegionEx(rdpPtr dev, rdpClientCon *clientCon)
-{
- struct stream *s;
- int flags;
-
- LLOGLN(10, ("rdpClientConProcessMsgClientRegionEx:"));
- s = clientCon->in_s;
-
- in_uint32_le(s, flags);
- in_uint32_le(s, clientCon->rect_id_ack);
- LLOGLN(10, ("rdpClientConProcessMsgClientRegionEx: flags 0x%8.8x", flags));
- LLOGLN(10, ("rdpClientConProcessMsgClientRegionEx: rect_id %d "
- "rect_id_ack %d", clientCon->rect_id, clientCon->rect_id_ack));
- return 0;
-}
-
-/******************************************************************************/
-static int
-rdpClientConProcessMsg(rdpPtr dev, rdpClientCon *clientCon)
-{
- int msg_type;
- struct stream *s;
-
- LLOGLN(10, ("rdpClientConProcessMsg:"));
- s = clientCon->in_s;
- in_uint16_le(s, msg_type);
- LLOGLN(10, ("rdpClientConProcessMsg: msg_type %d", msg_type));
- switch (msg_type)
- {
- case 103: /* client input */
- rdpClientConProcessMsgClientInput(dev, clientCon);
- break;
- case 104: /* client info */
- rdpClientConProcessMsgClientInfo(dev, clientCon);
- break;
- case 105: /* client region */
- rdpClientConProcessMsgClientRegion(dev, clientCon);
- break;
- case 106: /* client region ex */
- rdpClientConProcessMsgClientRegionEx(dev, clientCon);
- break;
- default:
- break;
- }
-
- return 0;
-}
-
-/******************************************************************************/
-static int
-rdpClientConGotData(ScreenPtr pScreen, rdpPtr dev, rdpClientCon *clientCon)
-{
- int rv;
-
- LLOGLN(10, ("rdpClientConGotData:"));
-
- rv = rdpClientConRecvMsg(dev, clientCon);
- if (rv == 0)
- {
- rv = rdpClientConProcessMsg(dev, clientCon);
- }
-
- return rv;
-}
-
-/******************************************************************************/
-static int
-rdpClientConGotControlConnection(ScreenPtr pScreen, rdpPtr dev,
- rdpClientCon *clientCon)
-{
- LLOGLN(0, ("rdpClientConGotControlConnection:"));
- return 0;
-}
-
-/******************************************************************************/
-static int
-rdpClientConGotControlData(ScreenPtr pScreen, rdpPtr dev,
- rdpClientCon *clientCon)
-{
- LLOGLN(0, ("rdpClientConGotControlData:"));
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConCheck(ScreenPtr pScreen)
-{
- rdpPtr dev;
- rdpClientCon *clientCon;
- fd_set rfds;
- struct timeval time;
- int max;
- int sel;
- int count;
-
- LLOGLN(10, ("rdpClientConCheck:"));
- dev = rdpGetDevFromScreen(pScreen);
- time.tv_sec = 0;
- time.tv_usec = 0;
- FD_ZERO(&rfds);
- count = 0;
- max = 0;
- if (dev->listen_sck > 0)
- {
- count++;
- FD_SET(LTOUI32(dev->listen_sck), &rfds);
- max = RDPMAX(dev->listen_sck, max);
- }
- clientCon = dev->clientConHead;
- while (clientCon != NULL)
- {
- if (clientCon->sck > 0)
- {
- count++;
- FD_SET(LTOUI32(clientCon->sck), &rfds);
- max = RDPMAX(clientCon->sck, max);
- }
- if (clientCon->sckControl > 0)
- {
- count++;
- FD_SET(LTOUI32(clientCon->sckControl), &rfds);
- max = RDPMAX(clientCon->sckControl, max);
- }
- if (clientCon->sckControlListener > 0)
- {
- count++;
- FD_SET(LTOUI32(clientCon->sckControlListener), &rfds);
- max = RDPMAX(clientCon->sckControlListener, max);
- }
- clientCon = clientCon->next;
- }
- if (count < 1)
- {
- sel = 0;
- }
- else
- {
- sel = select(max + 1, &rfds, 0, 0, &time);
- }
- if (sel < 1)
- {
- LLOGLN(10, ("rdpClientConCheck: no select"));
- return 0;
- }
- if (dev->listen_sck > 0)
- {
- if (FD_ISSET(LTOUI32(dev->listen_sck), &rfds))
- {
- rdpClientConGotConnection(pScreen, dev);
- }
- }
- clientCon = dev->clientConHead;
- while (clientCon != NULL)
- {
- if (clientCon->sck > 0)
- {
- if (FD_ISSET(LTOUI32(clientCon->sck), &rfds))
- {
- if (rdpClientConGotData(pScreen, dev, clientCon) != 0)
- {
- LLOGLN(0, ("rdpClientConCheck: rdpClientConGotData failed"));
- clientCon = dev->clientConHead;
- continue;
- }
- }
- }
- if (clientCon->sckControlListener > 0)
- {
- if (FD_ISSET(LTOUI32(clientCon->sckControlListener), &rfds))
- {
- if (rdpClientConGotControlConnection(pScreen, dev, clientCon) != 0)
- {
- LLOGLN(0, ("rdpClientConCheck: rdpClientConGotControlConnection failed"));
- clientCon = dev->clientConHead;
- continue;
- }
- }
- }
- if (clientCon->sckControl > 0)
- {
- if (FD_ISSET(LTOUI32(clientCon->sckControl), &rfds))
- {
- if (rdpClientConGotControlData(pScreen, dev, clientCon) != 0)
- {
- LLOGLN(0, ("rdpClientConCheck: rdpClientConGotControlData failed"));
- clientCon = dev->clientConHead;
- continue;
- }
- }
- }
- clientCon = clientCon->next;
- }
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConInit(rdpPtr dev)
-{
- int i;
-
- if (!g_directory_exist("/tmp/.xrdp"))
- {
- if (!g_create_dir("/tmp/.xrdp"))
- {
- if (!g_directory_exist("/tmp/.xrdp"))
- {
- LLOGLN(0, ("rdpup_init: g_create_dir failed"));
- return 0;
- }
- }
- g_chmod_hex("/tmp/.xrdp", 0x1777);
- }
- i = atoi(display);
- if (i < 1)
- {
- LLOGLN(0, ("rdpClientConInit: can not run at display < 1"));
- return 0;
- }
- g_sprintf(dev->uds_data, "/tmp/.xrdp/xrdp_display_%s", display);
- if (dev->listen_sck == 0)
- {
- unlink(dev->uds_data);
- dev->listen_sck = g_sck_local_socket_stream();
- if (g_sck_local_bind(dev->listen_sck, dev->uds_data) != 0)
- {
- LLOGLN(0, ("rdpClientConInit: g_tcp_local_bind failed"));
- return 1;
- }
- g_sck_listen(dev->listen_sck);
- AddEnabledDevice(dev->listen_sck);
- }
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConDeinit(rdpPtr dev)
-{
- LLOGLN(0, ("rdpClientConDeinit:"));
- if (dev->listen_sck != 0)
- {
- close(dev->listen_sck);
- unlink(dev->uds_data);
- }
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConBeginUpdate(rdpPtr dev, rdpClientCon *clientCon)
-{
- LLOGLN(10, ("rdpClientConBeginUpdate:"));
-
- if (clientCon->connected)
- {
- if (clientCon->begin)
- {
- return 0;
- }
- init_stream(clientCon->out_s, 0);
- s_push_layer(clientCon->out_s, iso_hdr, 8);
- out_uint16_le(clientCon->out_s, 1); /* begin update */
- out_uint16_le(clientCon->out_s, 4); /* size */
- clientCon->begin = TRUE;
- clientCon->count = 1;
- }
-
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConEndUpdate(rdpPtr dev, rdpClientCon *clientCon)
-{
- LLOGLN(10, ("rdpClientConEndUpdate"));
-
- if (clientCon->connected && clientCon->begin)
- {
- if (dev->do_dirty_ons)
- {
- /* in this mode, end update is only called in check dirty */
- rdpClientConSendPending(dev, clientCon);
- }
- else
- {
- rdpClientConScheduleDeferredUpdate(dev);
- }
- }
-
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConPreCheck(rdpPtr dev, rdpClientCon *clientCon, int in_size)
-{
- int rv;
-
- rv = 0;
- if (clientCon->begin == FALSE)
- {
- rdpClientConBeginUpdate(dev, clientCon);
- }
-
- if ((clientCon->out_s->p - clientCon->out_s->data) >
- (clientCon->out_s->size - (in_size + 20)))
- {
- s_mark_end(clientCon->out_s);
- if (rdpClientConSendMsg(dev, clientCon) != 0)
- {
- LLOGLN(0, ("rdpClientConPreCheck: rdpup_send_msg failed"));
- rv = 1;
- }
- clientCon->count = 0;
- init_stream(clientCon->out_s, 0);
- s_push_layer(clientCon->out_s, iso_hdr, 8);
- }
-
- return rv;
-}
-
-/******************************************************************************/
-int
-rdpClientConFillRect(rdpPtr dev, rdpClientCon *clientCon,
- short x, short y, int cx, int cy)
-{
- if (clientCon->connected)
- {
- LLOGLN(10, ("rdpClientConFillRect:"));
- rdpClientConPreCheck(dev, clientCon, 12);
- out_uint16_le(clientCon->out_s, 3); /* fill rect */
- out_uint16_le(clientCon->out_s, 12); /* size */
- clientCon->count++;
- out_uint16_le(clientCon->out_s, x);
- out_uint16_le(clientCon->out_s, y);
- out_uint16_le(clientCon->out_s, cx);
- out_uint16_le(clientCon->out_s, cy);
- }
-
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConScreenBlt(rdpPtr dev, rdpClientCon *clientCon,
- short x, short y, int cx, int cy, short srcx, short srcy)
-{
- if (clientCon->connected)
- {
- LLOGLN(10, ("rdpClientConScreenBlt: x %d y %d cx %d cy %d "
- "srcx %d srcy %d",
- x, y, cx, cy, srcx, srcy));
- rdpClientConPreCheck(dev, clientCon, 16);
- out_uint16_le(clientCon->out_s, 4); /* screen blt */
- out_uint16_le(clientCon->out_s, 16); /* size */
- clientCon->count++;
- out_uint16_le(clientCon->out_s, x);
- out_uint16_le(clientCon->out_s, y);
- out_uint16_le(clientCon->out_s, cx);
- out_uint16_le(clientCon->out_s, cy);
- out_uint16_le(clientCon->out_s, srcx);
- out_uint16_le(clientCon->out_s, srcy);
- }
-
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConSetClip(rdpPtr dev, rdpClientCon *clientCon,
- short x, short y, int cx, int cy)
-{
- if (clientCon->connected)
- {
- LLOGLN(10, ("rdpClientConSetClip:"));
- rdpClientConPreCheck(dev, clientCon, 12);
- out_uint16_le(clientCon->out_s, 10); /* set clip */
- out_uint16_le(clientCon->out_s, 12); /* size */
- clientCon->count++;
- out_uint16_le(clientCon->out_s, x);
- out_uint16_le(clientCon->out_s, y);
- out_uint16_le(clientCon->out_s, cx);
- out_uint16_le(clientCon->out_s, cy);
- }
-
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConResetClip(rdpPtr dev, rdpClientCon *clientCon)
-{
- if (clientCon->connected)
- {
- LLOGLN(10, ("rdpClientConResetClip:"));
- rdpClientConPreCheck(dev, clientCon, 4);
- out_uint16_le(clientCon->out_s, 11); /* reset clip */
- out_uint16_le(clientCon->out_s, 4); /* size */
- clientCon->count++;
- }
-
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConConvertPixel(rdpPtr dev, rdpClientCon *clientCon, int in_pixel)
-{
- int red;
- int green;
- int blue;
- int rv;
-
- rv = 0;
-
- if (dev->depth == 24)
- {
- if (clientCon->rdp_bpp == 24)
- {
- rv = in_pixel;
- SPLITCOLOR32(red, green, blue, rv);
- rv = COLOR24(red, green, blue);
- }
- else if (clientCon->rdp_bpp == 16)
- {
- rv = in_pixel;
- SPLITCOLOR32(red, green, blue, rv);
- rv = COLOR16(red, green, blue);
- }
- else if (clientCon->rdp_bpp == 15)
- {
- rv = in_pixel;
- SPLITCOLOR32(red, green, blue, rv);
- rv = COLOR15(red, green, blue);
- }
- else if (clientCon->rdp_bpp == 8)
- {
- rv = in_pixel;
- SPLITCOLOR32(red, green, blue, rv);
- rv = COLOR8(red, green, blue);
- }
- }
- else if (dev->depth == clientCon->rdp_bpp)
- {
- return in_pixel;
- }
-
- return rv;
-}
-
-/******************************************************************************/
-int
-rdpClientConConvertPixels(rdpPtr dev, rdpClientCon *clientCon,
- void *src, void *dst, int num_pixels)
-{
- unsigned int pixel;
- unsigned int red;
- unsigned int green;
- unsigned int blue;
- unsigned int *src32;
- unsigned int *dst32;
- unsigned short *dst16;
- unsigned char *dst8;
- int index;
-
- if (dev->depth == clientCon->rdp_bpp)
- {
- memcpy(dst, src, num_pixels * dev->Bpp);
- return 0;
- }
-
- if (dev->depth == 24)
- {
- src32 = (unsigned int *)src;
-
- if (clientCon->rdp_bpp == 24)
- {
- dst32 = (unsigned int *)dst;
-
- for (index = 0; index < num_pixels; index++)
- {
- pixel = *src32;
- *dst32 = pixel;
- dst32++;
- src32++;
- }
- }
- else if (clientCon->rdp_bpp == 16)
- {
- dst16 = (unsigned short *)dst;
-
- for (index = 0; index < num_pixels; index++)
- {
- pixel = *src32;
- SPLITCOLOR32(red, green, blue, pixel);
- pixel = COLOR16(red, green, blue);
- *dst16 = pixel;
- dst16++;
- src32++;
- }
- }
- else if (clientCon->rdp_bpp == 15)
- {
- dst16 = (unsigned short *)dst;
-
- for (index = 0; index < num_pixels; index++)
- {
- pixel = *src32;
- SPLITCOLOR32(red, green, blue, pixel);
- pixel = COLOR15(red, green, blue);
- *dst16 = pixel;
- dst16++;
- src32++;
- }
- }
- else if (clientCon->rdp_bpp == 8)
- {
- dst8 = (unsigned char *)dst;
-
- for (index = 0; index < num_pixels; index++)
- {
- pixel = *src32;
- SPLITCOLOR32(red, green, blue, pixel);
- pixel = COLOR8(red, green, blue);
- *dst8 = pixel;
- dst8++;
- src32++;
- }
- }
- }
-
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConAlphaPixels(void* src, void* dst, int num_pixels)
-{
- unsigned int* src32;
- unsigned char* dst8;
- int index;
-
- src32 = (unsigned int*)src;
- dst8 = (unsigned char*)dst;
- for (index = 0; index < num_pixels; index++)
- {
- *dst8 = (*src32) >> 24;
- dst8++;
- src32++;
- }
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConSetFgcolor(rdpPtr dev, rdpClientCon *clientCon, int fgcolor)
-{
- if (clientCon->connected)
- {
- LLOGLN(10, ("rdpClientConSetFgcolor:"));
- rdpClientConPreCheck(dev, clientCon, 8);
- out_uint16_le(clientCon->out_s, 12); /* set fgcolor */
- out_uint16_le(clientCon->out_s, 8); /* size */
- clientCon->count++;
- fgcolor = fgcolor & dev->Bpp_mask;
- fgcolor = rdpClientConConvertPixel(dev, clientCon, fgcolor) &
- clientCon->rdp_Bpp_mask;
- out_uint32_le(clientCon->out_s, fgcolor);
- }
-
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConSetBgcolor(rdpPtr dev, rdpClientCon *clientCon, int bgcolor)
-{
- if (clientCon->connected)
- {
- LLOGLN(10, ("rdpClientConSetBgcolor:"));
- rdpClientConPreCheck(dev, clientCon, 8);
- out_uint16_le(clientCon->out_s, 13); /* set bg color */
- out_uint16_le(clientCon->out_s, 8); /* size */
- clientCon->count++;
- bgcolor = bgcolor & dev->Bpp_mask;
- bgcolor = rdpClientConConvertPixel(dev, clientCon, bgcolor) &
- clientCon->rdp_Bpp_mask;
- out_uint32_le(clientCon->out_s, bgcolor);
- }
-
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConSetOpcode(rdpPtr dev, rdpClientCon *clientCon, int opcode)
-{
- if (clientCon->connected)
- {
- LLOGLN(10, ("rdpClientConSetOpcode:"));
- rdpClientConPreCheck(dev, clientCon, 6);
- out_uint16_le(clientCon->out_s, 14); /* set opcode */
- out_uint16_le(clientCon->out_s, 6); /* size */
- clientCon->count++;
- out_uint16_le(clientCon->out_s, g_rdp_opcodes[opcode & 0xf]);
- }
-
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConSetPen(rdpPtr dev, rdpClientCon *clientCon, int style, int width)
-{
- if (clientCon->connected)
- {
- LLOGLN(10, ("rdpClientConSetPen:"));
- rdpClientConPreCheck(dev, clientCon, 8);
- out_uint16_le(clientCon->out_s, 17); /* set pen */
- out_uint16_le(clientCon->out_s, 8); /* size */
- clientCon->count++;
- out_uint16_le(clientCon->out_s, style);
- out_uint16_le(clientCon->out_s, width);
- }
-
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConDrawLine(rdpPtr dev, rdpClientCon *clientCon,
- short x1, short y1, short x2, short y2)
-{
- if (clientCon->connected)
- {
- LLOGLN(10, ("rdpClientConDrawLine:"));
- rdpClientConPreCheck(dev, clientCon, 12);
- out_uint16_le(clientCon->out_s, 18); /* draw line */
- out_uint16_le(clientCon->out_s, 12); /* size */
- clientCon->count++;
- out_uint16_le(clientCon->out_s, x1);
- out_uint16_le(clientCon->out_s, y1);
- out_uint16_le(clientCon->out_s, x2);
- out_uint16_le(clientCon->out_s, y2);
- }
-
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConSetCursor(rdpPtr dev, rdpClientCon *clientCon,
- short x, short y, char *cur_data, char *cur_mask)
-{
- int size;
-
- if (clientCon->connected)
- {
- LLOGLN(10, ("rdpClientConSetCursor:"));
- size = 8 + 32 * (32 * 3) + 32 * (32 / 8);
- rdpClientConPreCheck(dev, clientCon, size);
- out_uint16_le(clientCon->out_s, 19); /* set cursor */
- out_uint16_le(clientCon->out_s, size); /* size */
- clientCon->count++;
- x = RDPMAX(0, x);
- x = RDPMIN(31, x);
- y = RDPMAX(0, y);
- y = RDPMIN(31, y);
- out_uint16_le(clientCon->out_s, x);
- out_uint16_le(clientCon->out_s, y);
- out_uint8a(clientCon->out_s, cur_data, 32 * (32 * 3));
- out_uint8a(clientCon->out_s, cur_mask, 32 * (32 / 8));
- }
-
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConSetCursorEx(rdpPtr dev, rdpClientCon *clientCon,
- short x, short y, char *cur_data,
- char *cur_mask, int bpp)
-{
- int size;
- int Bpp;
-
- if (clientCon->connected)
- {
- LLOGLN(10, ("rdpClientConSetCursorEx:"));
- Bpp = (bpp == 0) ? 3 : (bpp + 7) / 8;
- size = 10 + 32 * (32 * Bpp) + 32 * (32 / 8);
- rdpClientConPreCheck(dev, clientCon, size);
- out_uint16_le(clientCon->out_s, 51); /* set cursor ex */
- out_uint16_le(clientCon->out_s, size); /* size */
- clientCon->count++;
- x = RDPMAX(0, x);
- x = RDPMIN(31, x);
- y = RDPMAX(0, y);
- y = RDPMIN(31, y);
- out_uint16_le(clientCon->out_s, x);
- out_uint16_le(clientCon->out_s, y);
- out_uint16_le(clientCon->out_s, bpp);
- out_uint8a(clientCon->out_s, cur_data, 32 * (32 * Bpp));
- out_uint8a(clientCon->out_s, cur_mask, 32 * (32 / 8));
- }
-
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConCreateOsSurface(rdpPtr dev, rdpClientCon *clientCon,
- int rdpindex, int width, int height)
-{
- LLOGLN(10, ("rdpClientConCreateOsSurface:"));
-
- if (clientCon->connected)
- {
- LLOGLN(10, ("rdpClientConCreateOsSurface: width %d height %d", width, height));
- rdpClientConPreCheck(dev, clientCon, 12);
- out_uint16_le(clientCon->out_s, 20);
- out_uint16_le(clientCon->out_s, 12);
- clientCon->count++;
- out_uint32_le(clientCon->out_s, rdpindex);
- out_uint16_le(clientCon->out_s, width);
- out_uint16_le(clientCon->out_s, height);
- }
-
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConCreateOsSurfaceBpp(rdpPtr dev, rdpClientCon *clientCon,
- int rdpindex, int width, int height, int bpp)
-{
- LLOGLN(10, ("rdpClientConCreateOsSurfaceBpp:"));
- if (clientCon->connected)
- {
- LLOGLN(10, ("rdpClientConCreateOsSurfaceBpp: width %d height %d "
- "bpp %d", width, height, bpp));
- rdpClientConPreCheck(dev, clientCon, 13);
- out_uint16_le(clientCon->out_s, 31);
- out_uint16_le(clientCon->out_s, 13);
- clientCon->count++;
- out_uint32_le(clientCon->out_s, rdpindex);
- out_uint16_le(clientCon->out_s, width);
- out_uint16_le(clientCon->out_s, height);
- out_uint8(clientCon->out_s, bpp);
- }
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConSwitchOsSurface(rdpPtr dev, rdpClientCon *clientCon, int rdpindex)
-{
- LLOGLN(10, ("rdpClientConSwitchOsSurface:"));
-
- if (clientCon->connected)
- {
- if (clientCon->rdpIndex == rdpindex)
- {
- return 0;
- }
-
- clientCon->rdpIndex = rdpindex;
- LLOGLN(10, ("rdpClientConSwitchOsSurface: rdpindex %d", rdpindex));
- /* switch surface */
- rdpClientConPreCheck(dev, clientCon, 8);
- out_uint16_le(clientCon->out_s, 21);
- out_uint16_le(clientCon->out_s, 8);
- out_uint32_le(clientCon->out_s, rdpindex);
- clientCon->count++;
- }
-
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConDeleteOsSurface(rdpPtr dev, rdpClientCon *clientCon, int rdpindex)
-{
- LLOGLN(10, ("rdpClientConDeleteOsSurface: rdpindex %d", rdpindex));
-
- if (clientCon->connected)
- {
- LLOGLN(10, ("rdpClientConDeleteOsSurface: rdpindex %d", rdpindex));
- rdpClientConPreCheck(dev, clientCon, 8);
- out_uint16_le(clientCon->out_s, 22);
- out_uint16_le(clientCon->out_s, 8);
- clientCon->count++;
- out_uint32_le(clientCon->out_s, rdpindex);
- }
-
- return 0;
-}
-
-/*****************************************************************************/
-/* returns -1 on error */
-int
-rdpClientConAddOsBitmap(rdpPtr dev, rdpClientCon *clientCon,
- PixmapPtr pixmap, rdpPixmapPtr priv)
-{
- int index;
- int rv;
- int oldest;
- int oldest_index;
- int this_bytes;
-
- LLOGLN(10, ("rdpClientConAddOsBitmap:"));
- if (clientCon->connected == FALSE)
- {
- LLOGLN(10, ("rdpClientConAddOsBitmap: test error 1"));
- return -1;
- }
-
- if (clientCon->osBitmaps == NULL)
- {
- LLOGLN(10, ("rdpClientConAddOsBitmap: test error 2"));
- return -1;
- }
-
- this_bytes = pixmap->devKind * pixmap->drawable.height;
- if (this_bytes > MAX_OS_BYTES)
- {
- LLOGLN(10, ("rdpClientConAddOsBitmap: error, too big this_bytes %d "
- "width %d height %d", this_bytes,
- pixmap->drawable.height, pixmap->drawable.height));
- return -1;
- }
-
- oldest = 0x7fffffff;
- oldest_index = -1;
- rv = -1;
- index = 0;
-
- while (index < clientCon->maxOsBitmaps)
- {
- if (clientCon->osBitmaps[index].used == FALSE)
- {
- clientCon->osBitmaps[index].used = TRUE;
- clientCon->osBitmaps[index].pixmap = pixmap;
- clientCon->osBitmaps[index].priv = priv;
- clientCon->osBitmaps[index].stamp = clientCon->osBitmapStamp;
- clientCon->osBitmapStamp++;
- clientCon->osBitmapNumUsed++;
- rv = index;
- break;
- }
- else
- {
- if (clientCon->osBitmaps[index].stamp < oldest)
- {
- oldest = clientCon->osBitmaps[index].stamp;
- oldest_index = index;
- }
- }
- index++;
- }
-
- if (rv == -1)
- {
- if (oldest_index == -1)
- {
- LLOGLN(0, ("rdpClientConAddOsBitmap: error"));
- }
- else
- {
- LLOGLN(10, ("rdpClientConAddOsBitmap: too many pixmaps removing "
- "oldest_index %d", oldest_index));
- rdpClientConRemoveOsBitmap(dev, clientCon, oldest_index);
- rdpClientConDeleteOsSurface(dev, clientCon, oldest_index);
- clientCon->osBitmaps[oldest_index].used = TRUE;
- clientCon->osBitmaps[oldest_index].pixmap = pixmap;
- clientCon->osBitmaps[oldest_index].priv = priv;
- clientCon->osBitmaps[oldest_index].stamp = clientCon->osBitmapStamp;
- clientCon->osBitmapStamp++;
- clientCon->osBitmapNumUsed++;
- rv = oldest_index;
- }
- }
-
- if (rv < 0)
- {
- LLOGLN(10, ("rdpClientConAddOsBitmap: test error 3"));
- return rv;
- }
-
- clientCon->osBitmapAllocSize += this_bytes;
- LLOGLN(10, ("rdpClientConAddOsBitmap: this_bytes %d "
- "clientCon->osBitmapAllocSize %d",
- this_bytes, clientCon->osBitmapAllocSize));
-#if USE_MAX_OS_BYTES
- while (clientCon->osBitmapAllocSize > MAX_OS_BYTES)
- {
- LLOGLN(10, ("rdpClientConAddOsBitmap: must delete "
- "clientCon->osBitmapNumUsed %d",
- clientCon->osBitmapNumUsed));
- /* find oldest */
- oldest = 0x7fffffff;
- oldest_index = -1;
- index = 0;
- while (index < clientCon->maxOsBitmaps)
- {
- if (clientCon->osBitmaps[index].used &&
- (clientCon->osBitmaps[index].stamp < oldest))
- {
- oldest = clientCon->osBitmaps[index].stamp;
- oldest_index = index;
- }
- index++;
- }
- if (oldest_index == -1)
- {
- LLOGLN(0, ("rdpClientConAddOsBitmap: error 1"));
- break;
- }
- if (oldest_index == rv)
- {
- LLOGLN(0, ("rdpClientConAddOsBitmap: error 2"));
- break;
- }
- rdpClientConRemoveOsBitmap(dev, clientCon, oldest_index);
- rdpClientConDeleteOsSurface(dev, clientCon, oldest_index);
- }
-#endif
- LLOGLN(10, ("rdpClientConAddOsBitmap: new bitmap index %d", rv));
- LLOGLN(10, ("rdpClientConAddOsBitmap: clientCon->osBitmapNumUsed %d "
- "clientCon->osBitmapStamp 0x%8.8x",
- clientCon->osBitmapNumUsed, clientCon->osBitmapStamp));
- return rv;
-}
-
-/*****************************************************************************/
-int
-rdpClientConRemoveOsBitmap(rdpPtr dev, rdpClientCon *clientCon, int rdpindex)
-{
- PixmapPtr pixmap;
- rdpPixmapPtr priv;
- int this_bytes;
-
- if (clientCon->osBitmaps == NULL)
- {
- LLOGLN(10, ("rdpClientConRemoveOsBitmap: test error 1"));
- return 1;
- }
-
- LLOGLN(10, ("rdpClientConRemoveOsBitmap: index %d stamp %d",
- rdpindex, clientCon->osBitmaps[rdpindex].stamp));
-
- if ((rdpindex < 0) && (rdpindex >= clientCon->maxOsBitmaps))
- {
- LLOGLN(10, ("rdpClientConRemoveOsBitmap: test error 2"));
- return 1;
- }
-
- if (clientCon->osBitmaps[rdpindex].used)
- {
- pixmap = clientCon->osBitmaps[rdpindex].pixmap;
- priv = clientCon->osBitmaps[rdpindex].priv;
- rdpDrawItemRemoveAll(dev, priv);
- this_bytes = pixmap->devKind * pixmap->drawable.height;
- clientCon->osBitmapAllocSize -= this_bytes;
- LLOGLN(10, ("rdpClientConRemoveOsBitmap: this_bytes %d "
- "clientCon->osBitmapAllocSize %d", this_bytes,
- clientCon->osBitmapAllocSize));
- clientCon->osBitmaps[rdpindex].used = 0;
- clientCon->osBitmaps[rdpindex].pixmap = 0;
- clientCon->osBitmaps[rdpindex].priv = 0;
- clientCon->osBitmapNumUsed--;
- priv->status = 0;
- priv->con_number = 0;
- priv->use_count = 0;
- }
- else
- {
- LLOGLN(0, ("rdpup_remove_os_bitmap: error"));
- }
-
- LLOGLN(10, ("rdpup_remove_os_bitmap: clientCon->osBitmapNumUsed %d",
- clientCon->osBitmapNumUsed));
- return 0;
-}
-
-/*****************************************************************************/
-int
-rdpClientConUpdateOsUse(rdpPtr dev, rdpClientCon *clientCon, int rdpindex)
-{
- if (clientCon->osBitmaps == NULL)
- {
- return 1;
- }
-
- LLOGLN(10, ("rdpClientConUpdateOsUse: index %d stamp %d",
- rdpindex, clientCon->osBitmaps[rdpindex].stamp));
-
- if ((rdpindex < 0) && (rdpindex >= clientCon->maxOsBitmaps))
- {
- return 1;
- }
-
- if (clientCon->osBitmaps[rdpindex].used)
- {
- clientCon->osBitmaps[rdpindex].stamp = clientCon->osBitmapStamp;
- clientCon->osBitmapStamp++;
- }
- else
- {
- LLOGLN(0, ("rdpClientConUpdateOsUse: error rdpindex %d", rdpindex));
- }
-
- return 0;
-}
-
-/******************************************************************************/
-static CARD32
-rdpClientConDeferredUpdateCallback(OsTimerPtr timer, CARD32 now, pointer arg)
-{
- rdpPtr dev;
- rdpClientCon *clientCon;
-
- LLOGLN(10, ("rdpClientConDeferredUpdateCallback"));
-
- dev = (rdpPtr) arg;
- clientCon = dev->clientConHead;
- while (clientCon != NULL)
- {
- if (dev->do_dirty_ons)
- {
- if (clientCon->rectId == clientCon->rectIdAck)
- {
- rdpClientConCheckDirtyScreen(dev, clientCon);
- }
- else
- {
- LLOGLN(0, ("rdpClientConDeferredUpdateCallback: skipping"));
- }
- }
- else
- {
- rdpClientConSendPending(dev, clientCon);
- }
- clientCon = clientCon->next;
- }
- dev->sendUpdateScheduled = FALSE;
- return 0;
-}
-
-/******************************************************************************/
-void
-rdpClientConScheduleDeferredUpdate(rdpPtr dev)
-{
- if (dev->sendUpdateScheduled == FALSE)
- {
- dev->sendUpdateScheduled = TRUE;
- dev->sendUpdateTimer =
- TimerSet(dev->sendUpdateTimer, 0, 40,
- rdpClientConDeferredUpdateCallback, dev);
- }
-}
-
-/******************************************************************************/
-int
-rdpClientConCheckDirtyScreen(rdpPtr dev, rdpClientCon *clientCon)
-{
- return 0;
-}
-
-/******************************************************************************/
-static int
-rdpClientConSendPaintRectShmEx(rdpPtr dev, rdpClientCon *clientCon,
- struct image_data *id,
- RegionPtr dirtyReg,
- BoxPtr copyRects, int numCopyRects)
-{
- int index;
- int size;
- int num_rects_d;
- int num_rects_c;
- short x;
- short y;
- short cx;
- short cy;
- struct stream *s;
- BoxRec box;
-
- rdpClientConBeginUpdate(dev, clientCon);
-
- num_rects_d = REGION_NUM_RECTS(dirtyReg);
- num_rects_c = numCopyRects;
- if ((num_rects_c < 1) || (num_rects_d < 1))
- {
- LLOGLN(0, ("rdpClientConSendPaintRectShmEx: nothing to send"));
- return 0;
- }
- size = 2 + 2 + 2 + num_rects_d * 8 + 2 + num_rects_c * 8;
- size += 4 + 4 + 4 + 4 + 2 + 2;
- rdpClientConPreCheck(dev, clientCon, size);
-
- s = clientCon->out_s;
- out_uint16_le(s, 61);
- out_uint16_le(s, size);
- clientCon->count++;
-
- out_uint16_le(s, num_rects_d);
- for (index = 0; index < num_rects_d; index++)
- {
- box = REGION_RECTS(dirtyReg)[index];
- x = box.x1;
- y = box.y1;
- cx = box.x2 - box.x1;
- cy = box.y2 - box.y1;
- out_uint16_le(s, x);
- out_uint16_le(s, y);
- out_uint16_le(s, cx);
- out_uint16_le(s, cy);
- }
-
- out_uint16_le(s, num_rects_c);
- for (index = 0; index < num_rects_c; index++)
- {
- box = copyRects[index];
- x = box.x1;
- y = box.y1;
- cx = box.x2 - box.x1;
- cy = box.y2 - box.y1;
- out_uint16_le(s, x);
- out_uint16_le(s, y);
- out_uint16_le(s, cx);
- out_uint16_le(s, cy);
- }
-
- out_uint32_le(s, 0);
- clientCon->rect_id++;
- out_uint32_le(s, clientCon->rect_id);
- out_uint32_le(s, id->shmem_id);
- out_uint32_le(s, id->shmem_offset);
- out_uint16_le(s, clientCon->cap_width);
- out_uint16_le(s, clientCon->cap_height);
-
- rdpClientConEndUpdate(dev, clientCon);
-
- return 0;
-}
-
-/******************************************************************************/
-static CARD32
-rdpDeferredUpdateCallback(OsTimerPtr timer, CARD32 now, pointer arg)
-{
- rdpClientCon *clientCon;
- BoxPtr rects;
- int num_rects;
- struct image_data id;
-
- LLOGLN(10, ("rdpDeferredUpdateCallback:"));
- clientCon = (rdpClientCon *) arg;
-
- if ((clientCon->rect_id > clientCon->rect_id_ack) ||
- /* do not allow captures until we have the client_info */
- clientCon->client_info.size == 0)
- {
- LLOGLN(0, ("rdpDeferredUpdateCallback: reschedual rect_id %d "
- "rect_id_ack %d",
- clientCon->rect_id, clientCon->rect_id_ack));
- clientCon->updateTimer = TimerSet(clientCon->updateTimer, 0, 40,
- rdpDeferredUpdateCallback,
- clientCon);
- return 0;
- }
- else
- {
- LLOGLN(10, ("rdpDeferredUpdateCallback: sending"));
- }
- rdpClientConGetScreenImageRect(clientCon->dev, clientCon, &id);
- LLOGLN(10, ("rdpDeferredUpdateCallback: rdp_width %d rdp_height %d "
- "rdp_Bpp %d screen width %d screen height %d",
- clientCon->rdp_width, clientCon->rdp_height, clientCon->rdp_Bpp,
- id.width, id.height));
- clientCon->updateSchedualed = FALSE;
- rects = 0;
- num_rects = 0;
- LLOGLN(10, ("rdpDeferredUpdateCallback: capture_code %d",
- clientCon->client_info.capture_code));
- if (rdpCapture(clientCon, clientCon->dirtyRegion, &rects, &num_rects,
- id.pixels, id.width, id.height,
- id.lineBytes, XRDP_a8r8g8b8, id.shmem_pixels,
- clientCon->cap_width, clientCon->cap_height,
- clientCon->cap_width * clientCon->rdp_Bpp,
- clientCon->rdp_format, clientCon->client_info.capture_code))
- {
- LLOGLN(10, ("rdpDeferredUpdateCallback: num_rects %d", num_rects));
- rdpClientConSendPaintRectShmEx(clientCon->dev, clientCon, &id,
- clientCon->dirtyRegion,
- rects, num_rects);
- g_free(rects);
- }
- else
- {
- LLOGLN(0, ("rdpDeferredUpdateCallback: rdpCapture failed"));
- }
- rdpRegionDestroy(clientCon->dirtyRegion);
- clientCon->dirtyRegion = rdpRegionCreate(NullBox, 0);
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConAddDirtyScreenReg(rdpPtr dev, rdpClientCon *clientCon,
- RegionPtr reg)
-{
- LLOGLN(10, ("rdpClientConAddDirtyScreenReg:"));
-
- rdpRegionUnion(clientCon->dirtyRegion, clientCon->dirtyRegion, reg);
- if (clientCon->updateSchedualed == FALSE)
- {
- clientCon->updateTimer = TimerSet(clientCon->updateTimer, 0, 40,
- rdpDeferredUpdateCallback, clientCon);
- clientCon->updateSchedualed = TRUE;
- }
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConAddDirtyScreenBox(rdpPtr dev, rdpClientCon *clientCon,
- BoxPtr box)
-{
- RegionPtr reg;
-
- reg = rdpRegionCreate(box, 0);
- rdpClientConAddDirtyScreenReg(dev, clientCon, reg);
- rdpRegionDestroy(reg);
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConAddDirtyScreen(rdpPtr dev, rdpClientCon *clientCon,
- int x, int y, int cx, int cy)
-{
- BoxRec box;
-
- box.x1 = x;
- box.y1 = y;
- box.x2 = box.x1 + cx;
- box.y2 = box.y1 + cy;
- rdpClientConAddDirtyScreenBox(dev, clientCon, &box);
- return 0;
-}
-
-/******************************************************************************/
-void
-rdpClientConGetScreenImageRect(rdpPtr dev, rdpClientCon *clientCon,
- struct image_data *id)
-{
- id->width = dev->width;
- id->height = dev->height;
- id->bpp = clientCon->rdp_bpp;
- id->Bpp = clientCon->rdp_Bpp;
- id->lineBytes = dev->paddedWidthInBytes;
- id->pixels = dev->pfbMemory;
- id->shmem_pixels = clientCon->shmemptr;
- id->shmem_id = clientCon->shmemid;
- id->shmem_offset = 0;
- id->shmem_lineBytes = clientCon->shmem_lineBytes;
-}
-
-/******************************************************************************/
-void
-rdpClientConGetPixmapImageRect(rdpPtr dev, rdpClientCon *clientCon,
- PixmapPtr pPixmap, struct image_data *id)
-{
- id->width = pPixmap->drawable.width;
- id->height = pPixmap->drawable.height;
- id->bpp = clientCon->rdp_bpp;
- id->Bpp = clientCon->rdp_Bpp;
- id->lineBytes = pPixmap->devKind;
- id->pixels = (char *)(pPixmap->devPrivate.ptr);
- id->shmem_pixels = 0;
- id->shmem_id = 0;
- id->shmem_offset = 0;
- id->shmem_lineBytes = 0;
-}
-
-/******************************************************************************/
-void
-rdpClientConSendArea(rdpPtr dev, rdpClientCon *clientCon,
- struct image_data *id, int x, int y, int w, int h)
-{
- struct image_data lid;
- BoxRec box;
- int ly;
- int size;
- char *src;
- char *dst;
- struct stream *s;
-
- LLOGLN(10, ("rdpClientConSendArea: id %p x %d y %d w %d h %d", id, x, y, w, h));
-
- if (id == NULL)
- {
- rdpClientConGetScreenImageRect(dev, clientCon, &lid);
- id = &lid;
- }
-
- if (x >= id->width)
- {
- return;
- }
-
- if (y >= id->height)
- {
- return;
- }
-
- if (x < 0)
- {
- w += x;
- x = 0;
- }
-
- if (y < 0)
- {
- h += y;
- y = 0;
- }
-
- if (w <= 0)
- {
- return;
- }
-
- if (h <= 0)
- {
- return;
- }
-
- if (x + w > id->width)
- {
- w = id->width - x;
- }
-
- if (y + h > id->height)
- {
- h = id->height - y;
- }
-
- if (clientCon->connected && clientCon->begin)
- {
- if (id->shmem_pixels != 0)
- {
- LLOGLN(10, ("rdpClientConSendArea: using shmem"));
- box.x1 = x;
- box.y1 = y;
- box.x2 = box.x1 + w;
- box.y2 = box.y1 + h;
- src = id->pixels;
- src += y * id->lineBytes;
- src += x * dev->Bpp;
- dst = id->shmem_pixels + id->shmem_offset;
- dst += y * id->shmem_lineBytes;
- dst += x * clientCon->rdp_Bpp;
- ly = y;
- while (ly < y + h)
- {
- rdpClientConConvertPixels(dev, clientCon, src, dst, w);
- src += id->lineBytes;
- dst += id->shmem_lineBytes;
- ly += 1;
- }
- size = 36;
- rdpClientConPreCheck(dev, clientCon, size);
- s = clientCon->out_s;
- out_uint16_le(s, 60);
- out_uint16_le(s, size);
- clientCon->count++;
- LLOGLN(10, ("rdpClientConSendArea: 2 x %d y %d w %d h %d", x, y, w, h));
- out_uint16_le(s, x);
- out_uint16_le(s, y);
- out_uint16_le(s, w);
- out_uint16_le(s, h);
- out_uint32_le(s, 0);
- clientCon->rect_id++;
- out_uint32_le(s, clientCon->rect_id);
- out_uint32_le(s, id->shmem_id);
- out_uint32_le(s, id->shmem_offset);
- out_uint16_le(s, id->width);
- out_uint16_le(s, id->height);
- out_uint16_le(s, x);
- out_uint16_le(s, y);
- rdpRegionUnionRect(clientCon->shmRegion, &box);
- return;
- }
- }
-}
-
-/******************************************************************************/
-int
-rdpClientConAddAllReg(rdpPtr dev, RegionPtr reg, DrawablePtr pDrawable)
-{
- rdpClientCon *clientCon;
- Bool drw_is_vis;
-
- drw_is_vis = XRDP_DRAWABLE_IS_VISIBLE(dev, pDrawable);
- if (!drw_is_vis)
- {
- return 0;
- }
- clientCon = dev->clientConHead;
- while (clientCon != NULL)
- {
- rdpClientConAddDirtyScreenReg(dev, clientCon, reg);
- clientCon = clientCon->next;
- }
- return 0;
-}
-
-/******************************************************************************/
-int
-rdpClientConAddAllBox(rdpPtr dev, BoxPtr box, DrawablePtr pDrawable)
-{
- rdpClientCon *clientCon;
- Bool drw_is_vis;
-
- drw_is_vis = XRDP_DRAWABLE_IS_VISIBLE(dev, pDrawable);
- if (!drw_is_vis)
- {
- return 0;
- }
- clientCon = dev->clientConHead;
- while (clientCon != NULL)
- {
- rdpClientConAddDirtyScreenBox(dev, clientCon, box);
- clientCon = clientCon->next;
- }
- return 0;
-}
generated by cgit v1.2.3 (git 2.46.0) at 2025-11-09 20:42:08 +0000