/* software decode */ int surface_cmd(rdpRdp * rdp, STREAM s) { int cmdType; int frameAction; int frameId; int destLeft; int destTop; int destRight; int destBottom; int bpp; int codecID; int width; int height; int bitmapDataLength; //printf("surface_cmd: size %d\n", s->end - s->p); //hexdump(s->p, 1024); frameId = 0; while (s->p < s->end) { in_uint16_le(s, cmdType); //printf(" surface_cmd: %d\n", cmdType); switch (cmdType) { case CMDTYPE_FRAME_MARKER: in_uint16_le(s, frameAction); in_uint32_le(s, frameId); //printf(" surface_cmd: CMDTYPE_FRAME_MARKER %d %d\n", frameAction, frameId); if (frameAction == SURFACECMD_FRAMEACTION_END) { rdp_send_frame_ack(rdp, frameId); } break; case CMDTYPE_STREAM_SURFACE_BITS: in_uint16_le(s, destLeft); in_uint16_le(s, destTop); in_uint16_le(s, destRight); in_uint16_le(s, destBottom); in_uint8(s, bpp); in_uint8s(s, 2); in_uint8(s, codecID); in_uint16_le(s, width); in_uint16_le(s, height); in_uint32_le(s, bitmapDataLength); in_uint8s(s, bitmapDataLength); //printf(" surface_cmd: CMDTYPE_STREAM_SURFACE_BITS " // "id %d width %d height %d bpp %d size %d\n", // codecID, width, height, bpp, bitmapDataLength); break; } } return 0; }
/* return error */ static int APP_CC process_server_composite(struct mod *mod, struct stream *s) { int rv; int srcidx; int srcformat; int srcwidth; int srcrepeat; int transform[10]; int mskflags; int mskidx; int mskformat; int mskwidth; int mskrepeat; int op; int srcx; int srcy; int mskx; int msky; int dstx; int dsty; int width; int height; int dstformat; in_uint16_le(s, srcidx); in_uint32_le(s, srcformat); in_uint16_le(s, srcwidth); in_uint8(s, srcrepeat); g_memcpy(transform, s->p, 40); in_uint8s(s, 40); in_uint8(s, mskflags); in_uint16_le(s, mskidx); in_uint32_le(s, mskformat); in_uint16_le(s, mskwidth); in_uint8(s, mskrepeat); in_uint8(s, op); in_sint16_le(s, srcx); in_sint16_le(s, srcy); in_sint16_le(s, mskx); in_sint16_le(s, msky); in_sint16_le(s, dstx); in_sint16_le(s, dsty); in_uint16_le(s, width); in_uint16_le(s, height); in_uint32_le(s, dstformat); rv = mod->server_composite(mod, srcidx, srcformat, srcwidth, srcrepeat, transform, mskflags, mskidx, mskformat, mskwidth, mskrepeat, op, srcx, srcy, mskx, msky, dstx, dsty, width, height, dstformat); return rv; }
/* Parse a pen */ static BOOL rdp_parse_pen(STREAM s, PEN * pen, uint32 present) { if (present & 1) in_uint8(s, pen->style); if (present & 2) in_uint8(s, pen->width); if (present & 4) rdp_in_colour(s, &pen->colour); return s_check(s); }
/* Process a licence packet */ void licence_process(RDConnectionRef conn, RDStreamRef s) { uint8 tag; in_uint8(s, tag); in_uint8s(s, 3); /* version, length */ switch (tag) { case LICENCE_TAG_DEMAND: licence_process_demand(conn, s); break; case LICENCE_TAG_AUTHREQ: licence_process_authreq(conn, s); break; case LICENCE_TAG_ISSUE: licence_process_issue(conn, s); break; case LICENCE_TAG_REISSUE: case LICENCE_TAG_RESULT: break; default: unimpl("licence tag 0x%x\n", tag); } }
void nego_process_negotiation_failure(NEGO *nego, STREAM s) { uint8 flags; uint16 length; uint32 failureCode; in_uint8(s, flags); in_uint16_le(s, length); in_uint32_le(s, failureCode); switch (failureCode) { case SSL_REQUIRED_BY_SERVER: //printf("Error: SSL_REQUIRED_BY_SERVER\n"); break; case SSL_NOT_ALLOWED_BY_SERVER: //printf("Error: SSL_NOT_ALLOWED_BY_SERVER\n"); break; case SSL_CERT_NOT_ON_SERVER: //printf("Error: SSL_CERT_NOT_ON_SERVER\n"); break; case INCONSISTENT_FLAGS: //printf("Error: INCONSISTENT_FLAGS\n"); break; case HYBRID_REQUIRED_BY_SERVER: //printf("Error: HYBRID_REQUIRED_BY_SERVER\n"); break; default: printf("Error: Unknown protocol security error %d\n", failureCode); break; } }
/* data in from client ( clinet -> xrdp -> chansrv ) */ int APP_CC sound_data_in(struct stream *s, int chan_id, int chan_flags, int length, int total_length) { int code; int size; print_got_here(); in_uint8(s, code); in_uint8s(s, 1); in_uint16_le(s, size); switch (code) { case SNDC_WAVECONFIRM: sound_process_wave_confirm(s, size); break; case SNDC_TRAINING: sound_process_training(s, size); break; case SNDC_FORMATS: sound_process_formats(s, size); break; default: LOG(0, ("sound_data_in: unknown code %d size %d", code, size)); break; } return 0; }
/* Parse bounds information */ static BOOL rdp_parse_bounds(STREAM s, BOUNDS * bounds) { uint8 present; in_uint8(s, present); if (present & 1) rdp_in_coord(s, &bounds->left, False); else if (present & 16) rdp_in_coord(s, &bounds->left, True); if (present & 2) rdp_in_coord(s, &bounds->top, False); else if (present & 32) rdp_in_coord(s, &bounds->top, True); if (present & 4) rdp_in_coord(s, &bounds->right, False); else if (present & 64) rdp_in_coord(s, &bounds->right, True); if (present & 8) rdp_in_coord(s, &bounds->bottom, False); else if (present & 128) rdp_in_coord(s, &bounds->bottom, True); return s_check(s); }
/* Process a desktop save order */ static void process_desksave(STREAM s, DESKSAVE_ORDER * os, uint32 present, BOOL delta) { int width, height; if (present & 0x01) in_uint32_le(s, os->offset); if (present & 0x02) rdp_in_coord(s, &os->left, delta); if (present & 0x04) rdp_in_coord(s, &os->top, delta); if (present & 0x08) rdp_in_coord(s, &os->right, delta); if (present & 0x10) rdp_in_coord(s, &os->bottom, delta); if (present & 0x20) in_uint8(s, os->action); DEBUG(("DESKSAVE(l=%d,t=%d,r=%d,b=%d,off=%d,op=%d)\n", os->left, os->top, os->right, os->bottom, os->offset, os->action)); width = os->right - os->left + 1; height = os->bottom - os->top + 1; if (os->action == 0) ui_desktop_save(os->offset, os->left, os->top, width, height); else ui_desktop_restore(os->offset, os->left, os->top, width, height); }
/* Process a pattern blt order */ static void process_patblt(STREAM s, PATBLT_ORDER * os, uint32 present, BOOL delta) { if (present & 0x0001) rdp_in_coord(s, &os->x, delta); if (present & 0x0002) rdp_in_coord(s, &os->y, delta); if (present & 0x0004) rdp_in_coord(s, &os->cx, delta); if (present & 0x0008) rdp_in_coord(s, &os->cy, delta); if (present & 0x0010) in_uint8(s, os->opcode); if (present & 0x0020) rdp_in_colour(s, &os->bgcolour); if (present & 0x0040) rdp_in_colour(s, &os->fgcolour); rdp_parse_brush(s, &os->brush, present >> 7); DEBUG(("PATBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,bs=%d,bg=0x%x,fg=0x%x)\n", os->opcode, os->x, os->y, os->cx, os->cy, os->brush.style, os->bgcolour, os->fgcolour)); ui_patblt(ROP2_P(os->opcode), os->x, os->y, os->cx, os->cy, &os->brush, os->bgcolour, os->fgcolour); }
/* Read field indicating which parameters are present */ static void rdp_in_present(STREAM s, uint32 * present, uint8 flags, int size) { uint8 bits; int i; if (flags & RDP_ORDER_SMALL) { size--; } if (flags & RDP_ORDER_TINY) { if (size < 2) size = 0; else size -= 2; } *present = 0; for (i = 0; i < size; i++) { in_uint8(s, bits); *present |= bits << (i * 8); } }
/* return error */ static int APP_CC process_server_paint_rect_bpp(struct mod *mod, struct stream *s) { int rv; int x; int y; int cx; int cy; int len_bmpdata; char *bmpdata; int width; int height; int srcx; int srcy; int bpp; in_sint16_le(s, x); in_sint16_le(s, y); in_uint16_le(s, cx); in_uint16_le(s, cy); in_uint32_le(s, len_bmpdata); in_uint8p(s, bmpdata, len_bmpdata); in_uint16_le(s, width); in_uint16_le(s, height); in_sint16_le(s, srcx); in_sint16_le(s, srcy); in_uint8(s, bpp); rv = mod->server_paint_rect_bpp(mod, x, y, cx, cy, bmpdata, width, height, srcx, srcy, bpp); return rv; }
/* Process a licence packet */ void licence_process(RDPCLIENT * This, STREAM s) { uint8 tag; in_uint8(s, tag); in_uint8s(s, 3); /* version, length */ switch (tag) { case LICENCE_TAG_DEMAND: licence_process_demand(This, s); break; case LICENCE_TAG_AUTHREQ: licence_process_authreq(This, s); break; case LICENCE_TAG_ISSUE: licence_process_issue(This, s); break; case LICENCE_TAG_REISSUE: case LICENCE_TAG_RESULT: break; default: unimpl("licence tag 0x%x\n", tag); } }
/* Process a screen blt order */ static void process_screenblt(STREAM s, SCREENBLT_ORDER * os, uint32 present, BOOL delta) { if (present & 0x0001) rdp_in_coord(s, &os->x, delta); if (present & 0x0002) rdp_in_coord(s, &os->y, delta); if (present & 0x0004) rdp_in_coord(s, &os->cx, delta); if (present & 0x0008) rdp_in_coord(s, &os->cy, delta); if (present & 0x0010) in_uint8(s, os->opcode); if (present & 0x0020) rdp_in_coord(s, &os->srcx, delta); if (present & 0x0040) rdp_in_coord(s, &os->srcy, delta); DEBUG(("SCREENBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,srcx=%d,srcy=%d)\n", os->opcode, os->x, os->y, os->cx, os->cy, os->srcx, os->srcy)); ui_screenblt(ROP2_S(os->opcode), os->x, os->y, os->cx, os->cy, os->srcx, os->srcy); }
/* Try to read TPKT header for X.224 from stream and return length * (including the 4 bytes TPKT header already read). * If not possible then return untouched stream and length -1. */ static int tpkt_input_header(STREAM s) { if (*s->p == 3) /* Peeking is less ugly than rewinding */ { uint8 version; uint8 reserved; uint16 length; in_uint8(s, version); in_uint8(s, reserved); in_uint16_be(s, length); return length; } return -1; /* Probably Fast-Path */ }
/* Receive a message on the ISO layer, return code */ static STREAM iso_recv_msg(uint8 * code, uint8 * rdpver) { STREAM s; uint16 length; uint8 version; s = tcp_recv(NULL, 4); if (s == NULL) return NULL; in_uint8(s, version); if (rdpver != NULL) *rdpver = version; if (version == 3) { in_uint8s(s, 1); /* pad */ in_uint16_be(s, length); } else { in_uint8(s, length); if (length & 0x80) { length &= ~0x80; next_be(s, length); } } if (length < 4) { error("Bad packet header\n"); return NULL; } s = tcp_recv(s, length - 4); if (s == NULL) return NULL; if (version != 3) return s; in_uint8s(s, 1); /* hdrlen */ in_uint8(s, *code); if (*code == ISO_PDU_DT) { in_uint8s(s, 1); /* eot */ return s; } in_uint8s(s, 5); /* dst_ref, src_ref, class */ return s; }
static void rdpsnd_process(STREAM s) { uint16 len; while (!s_check_end(s)) { /* New packet */ if (packet.size == 0) { if ((s->end - s->p) < 4) { logger(Sound, Error, "rdpsnd_process(), split at packet header, things will go south from here..."); return; } in_uint8(s, packet_opcode); in_uint8s(s, 1); /* Padding */ in_uint16_le(s, len); logger(Sound, Debug, "rdpsnd_process(), Opcode = 0x%x Length= %d", (int) packet_opcode, (int) len); packet.p = packet.data; packet.end = packet.data + len; packet.size = len; } else { len = MIN(s->end - s->p, packet.end - packet.p); /* Microsoft's server is so broken it's not even funny... */ if (packet_opcode == SNDC_WAVE) { if ((packet.p - packet.data) < 12) len = MIN(len, 12 - (packet.p - packet.data)); else if ((packet.p - packet.data) == 12) { logger(Sound, Debug, "rdpsnd_process(), eating 4 bytes of %d bytes...", len); in_uint8s(s, 4); len -= 4; } } in_uint8a(s, packet.p, len); packet.p += len; } /* Packet fully assembled */ if (packet.p == packet.end) { packet.p = packet.data; rdpsnd_process_packet(packet_opcode, &packet); packet.size = 0; } } }
void rdp_process_bitmapcache_hostsupport_capset(rdpRdp * rdp, STREAM s) { uint8 cacheVersion; in_uint8(s, cacheVersion); /* cacheVersion, must be set to BITMAPCACHE_REV2 */ /* pad (1 byte) */ /* pad (2 bytes) */ }
/* returns error */ static int APP_CC rdp_iso_recv_msg(struct rdp_iso *self, struct stream *s, int *code) { int ver; int len; *code = 0; if (rdp_tcp_recv(self->tcp_layer, s, 4) != 0) { DEBUG((" out rdp_iso_recv_msg error rdp_tcp_recv 1 failed")); return 1; } in_uint8(s, ver); if (ver != 3) { DEBUG((" out rdp_iso_recv_msg error ver != 3")); return 1; } in_uint8s(s, 1); in_uint16_be(s, len); if (rdp_tcp_recv(self->tcp_layer, s, len - 4) != 0) { DEBUG((" out rdp_iso_recv_msg error rdp_tcp_recv 2 failed")); return 1; } in_uint8s(s, 1); in_uint8(s, *code); if (*code == ISO_PDU_DT) { in_uint8s(s, 1); } else { in_uint8s(s, 5); } return 0; }
static void rdpsnd_process(STREAM s) { uint16 len; while (!s_check_end(s)) { /* New packet */ if (packet.size == 0) { if ((s->end - s->p) < 4) { error("RDPSND: Split at packet header. Things will go south from here...\n"); return; } in_uint8(s, packet_opcode); in_uint8s(s, 1); /* Padding */ in_uint16_le(s, len); DEBUG_SOUND(("RDPSND: == Opcode %x Length: %d ==\n", (int) packet_opcode, (int) len)); packet.p = packet.data; packet.end = packet.data + len; packet.size = len; } else { len = MIN(s->end - s->p, packet.end - packet.p); /* Microsoft's server is so broken it's not even funny... */ if (packet_opcode == RDPSND_WRITE) { if ((packet.p - packet.data) < 12) len = MIN(len, 12 - (packet.p - packet.data)); else if ((packet.p - packet.data) == 12) { DEBUG_SOUND(("RDPSND: Eating 4 bytes of %d bytes...\n", len)); in_uint8s(s, 4); len -= 4; } } in_uint8a(s, packet.p, len); packet.p += len; } /* Packet fully assembled */ if (packet.p == packet.end) { packet.p = packet.data; rdpsnd_process_packet(packet_opcode, &packet); packet.size = 0; } } }
/* Process a Licensing packet */ void licence_process(rdpLicence * licence, STREAM s) { uint8 tag; uint16 wMsgSize; uint8* license_start = s->p; /* Licensing Preamble */ in_uint8(s, tag); /* bMsgType */ in_uint8s(s, 1); /* Ignoring bVersion */ in_uint16_le(s, wMsgSize); /* Now pointing at LicensingMessage */ switch (tag) { case LICENSE_REQUEST: DEBUG("LICENSE_REQUEST\n"); licence_process_request(licence, s); ASSERT(s->p == license_start + wMsgSize); break; case LICENSE_PLATFORM_CHALLENGE: DEBUG("LICENCE PLATFORM_CHALLENGE\n"); licence_process_platform_challenge(licence, s); break; case NEW_LICENSE: DEBUG("NEW_LICENSE\n"); licence_process_new_license(licence, s); break; case UPGRADE_LICENSE: DEBUG("UPGRADE_LICENSE\n"); break; case LICENCE_ERROR_ALERT: DEBUG("LICENCE ERROR_ALERT - assuming it is a license grant\n"); { uint32 dwErrorCode, dwStateTransition; uint32 wBlobType, wBlobLen; in_uint32_le(s, dwErrorCode); in_uint32_le(s, dwStateTransition); DEBUG("dwErrorCode %x dwStateTransition %x\n", dwErrorCode, dwStateTransition); in_uint16_le(s, wBlobType); in_uint16_le(s, wBlobLen); DEBUG("bbErrorInfo: wBlobType %x wBlobLen %x\n", wBlobType, wBlobLen); /* hexdump(s->p, wBlobLen); */ } licence->licence_issued = True; /* TODO ... */ break; default: ui_unimpl(licence->sec->rdp->inst, "Unknown licence tag 0x%x\n", tag); } s->p = license_start + wMsgSize; /* FIXME: Shouldn't be necessary if parsed properly */ ASSERT(s->p <= s->end); }
/* Process a memory blt order */ static void process_memblt(STREAM s, MEMBLT_ORDER * os, uint32 present, BOOL delta) { HBITMAP bitmap; if (present & 0x0001) { in_uint8(s, os->cache_id); in_uint8(s, os->colour_table); } if (present & 0x0002) rdp_in_coord(s, &os->x, delta); if (present & 0x0004) rdp_in_coord(s, &os->y, delta); if (present & 0x0008) rdp_in_coord(s, &os->cx, delta); if (present & 0x0010) rdp_in_coord(s, &os->cy, delta); if (present & 0x0020) in_uint8(s, os->opcode); if (present & 0x0040) rdp_in_coord(s, &os->srcx, delta); if (present & 0x0080) rdp_in_coord(s, &os->srcy, delta); if (present & 0x0100) in_uint16_le(s, os->cache_idx); DEBUG(("MEMBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,id=%d,idx=%d)\n", os->opcode, os->x, os->y, os->cx, os->cy, os->cache_id, os->cache_idx)); bitmap = cache_get_bitmap(os->cache_id, os->cache_idx); if (bitmap == NULL) return; ui_memblt(ROP2_S(os->opcode), os->x, os->y, os->cx, os->cy, bitmap, os->srcx, os->srcy); }
/* Receive a packet from tcp and return stream. * If no ptype then only TPKT header with X.224 is accepted. * If ptype then Fast-Path packets are accepted too. * Return NULL on error. */ STREAM tpkt_recv(rdpIso * iso, uint8 * pcode, isoRecvType * ptype) { STREAM s; int length; s = tcp_recv(iso->tcp, NULL, 4); if (s == NULL) return NULL; length = tpkt_input_header(s); if (length >= 0) { /* Valid TPKT header, payload is X.224 TPDU */ if (ptype != NULL) *ptype = ISO_RECV_X224; s = x224_recv(iso, s, length, pcode); return s; } else if (ptype != NULL) { /* Fast-Path header */ uint8 fpInputHeader; in_uint8(s, fpInputHeader); ASSERT((fpInputHeader & 3) == 0); /* assume actionCode FASTPATH_OUTPUT_ACTION_FASTPATH */ *ptype = (fpInputHeader & 0x80) ? ISO_RECV_FAST_PATH_ENCRYPTED : ISO_RECV_FAST_PATH; /* TODO: 0x40 FASTPATH_OUTPUT_SECURE_CHECKSUM indicates salted MAC */ in_uint8(s, length); if (length & 0x80) { length &= ~0x80; next_be(s, length); } s = tcp_recv(iso->tcp, s, length - 4); return s; } return NULL; /* Fast-Path not allowed */ }
/* returns error returns 0 if everything is ok returns 1 if problem reading file */ static int APP_CC l_file_read_sections(int fd, int max_file_size, struct list *names) { struct stream *s; char text[FILE_MAX_LINE_BYTES]; char c; int in_it; int in_it_index; int len; int index; int rv; rv = 0; g_file_seek(fd, 0); in_it_index = 0; in_it = 0; g_memset(text, 0, FILE_MAX_LINE_BYTES); list_clear(names); make_stream(s); init_stream(s, max_file_size); len = g_file_read(fd, s->data, max_file_size); if (len > 0) { s->end = s->p + len; for (index = 0; index < len; index++) { in_uint8(s, c); if (c == '[') { in_it = 1; } else if (c == ']') { list_add_item(names, (tbus)g_strdup(text)); in_it = 0; in_it_index = 0; g_memset(text, 0, FILE_MAX_LINE_BYTES); } else if (in_it) { text[in_it_index] = c; in_it_index++; } } } else if (len < 0) { rv = 1; } free_stream(s); return rv; }
bool APP_CC xrdp_iso_parse_connection_request(struct xrdp_iso* self, struct stream* s, int code) { unsigned char type; unsigned char flags; unsigned short length; unsigned int protocol; // Get cookie char* p = g_strstr(s->p, "\r\n"); if (p != NULL) // There is a cookie or a routingToken { int cookie_len = p - s->p; if (cookie_len > 0) { char* cookie = g_malloc(cookie_len + 1, 1); g_strncpy(cookie, s->p, cookie_len); printf("cookie: %s\n", cookie); s->p += (cookie_len + 2); // CR+LF g_free(cookie); } } if (s->p == s->end) { return true; } // parse rdpNegData in_uint8(s, type); // type in_uint8(s, flags); // flags in_uint16_le(s, length); // length in_uint32_le(s, protocol); // selectedProtocol if (type == TYPE_RDP_NEG_REQ && length == RDP_NEG_REQ_LEN) { self->need_negotiation_response = true; return true; } self->mcs_layer->sec_layer->rdp_layer->client_info.support_network_detection = false; return true; }
/* Receive a message on the ISO layer, return code */ static STREAM iso_recv_msg(RDPCLIENT * This, uint8 * code, uint8 * rdpver) { STREAM s; uint16 length; uint8 version; s = tcp_recv(This, NULL, 4); if (s == NULL) return NULL; in_uint8(s, version); if (rdpver != NULL) *rdpver = version; if (version == 3) { in_uint8s(s, 1); /* pad */ in_uint16_be(s, length); } else { in_uint8(s, length); if (length & 0x80) { length &= ~0x80; next_be(s, length); } } s = tcp_recv(This, s, length - 4); if (s == NULL) return NULL; if (version != 3) return s; in_uint8s(s, 1); /* hdrlen */ in_uint8(s, *code); if (*code == ISO_PDU_DT) { in_uint8s(s, 1); /* eot */ return s; } in_uint8s(s, 5); /* dst_ref, src_ref, class */ return s; }
/* Parse a brush */ static BOOL rdp_parse_brush(STREAM s, BRUSH * brush, uint32 present) { if (present & 1) in_uint8(s, brush->xorigin); if (present & 2) in_uint8(s, brush->yorigin); if (present & 4) in_uint8(s, brush->style); if (present & 8) in_uint8(s, brush->pattern[0]); if (present & 16) in_uint8a(s, &brush->pattern[1], 7); return s_check(s); }
/* Receive a message on the ISO layer, return code */ static STREAM iso_recv_msg(uint8 * code) { STREAM s; uint16 length; uint8 version; s = tcp_recv(4); if (s == NULL) { return NULL; } in_uint8(s, version); if (version != 3) { error("TPKT v%d\n", version); return NULL; } in_uint8s(s, 1); /* pad */ in_uint16_be(s, length); s = tcp_recv(length - 4); if (s == NULL) return NULL; in_uint8s(s, 1); /* hdrlen */ in_uint8(s, *code); if (*code == ISO_PDU_DT) { in_uint8s(s, 1); /* eot */ return s; } in_uint8s(s, 5); /* dst_ref, src_ref, class */ return s; }
void rdp_process_window_capset(rdpRdp * rdp, STREAM s) { uint32 wndSupportLevel; uint8 numIconCaches; uint16 numIconCacheEntries; in_uint32_le(s, wndSupportLevel); /* wndSupportLevel */ in_uint8(s, numIconCaches); /* numIconCaches */ in_uint16_le(s, numIconCacheEntries); /* numIconCacheEntries */ rail_process_window_capset(rdp->rail_session, wndSupportLevel, numIconCaches, numIconCacheEntries); }
/* Read a co-ordinate (16-bit, or 8-bit delta) */ static void rdp_in_coord(STREAM s, uint16 * coord, BOOL delta) { sint8 change; if (delta) { in_uint8(s, change); *coord += change; } else { in_uint16_le(s, *coord); } }
void nego_recv(NEGO *nego, STREAM s) { uint8 type; in_uint8(s, type); /* Type */ switch (type) { case TYPE_RDP_NEG_RSP: nego_process_negotiation_response(nego, s); break; case TYPE_RDP_NEG_FAILURE: nego_process_negotiation_failure(nego, s); break; } }