static int cmd_keylen(int transport, int argc, char *argv[])
{
uint8_t array[8];
uint16_t handle, keylen;
int err;
OPT_HELP(1, NULL);
handle = atoi(argv[0]);
memset(array, 0, sizeof(array));
array[0] = handle & 0xff;
array[1] = handle >> 8;
err = transport_read(transport, CSR_VARID_CRYPT_KEY_LENGTH, array, 8);
if (err < 0) {
errno = -err;
return -1;
}
handle = array[0] | (array[1] << 8);
keylen = array[2] | (array[3] << 8);
printf("Crypt key length: %d bit\n", keylen * 8);
return 0;
}
static int cmd_builddef(int transport, int argc, char *argv[])
{
uint8_t array[8];
uint16_t def = 0x0000, nextdef = 0x0000;
int err = 0;
OPT_HELP(0, NULL);
printf("Build definitions:\n");
while (1) {
memset(array, 0, sizeof(array));
array[0] = def & 0xff;
array[1] = def >> 8;
err = transport_read(transport, CSR_VARID_GET_NEXT_BUILDDEF, array, 8);
if (err < 0) {
errno = -err;
break;
}
nextdef = array[2] | (array[3] << 8);
if (nextdef == 0x0000)
break;
def = nextdef;
printf("0x%04x - %s\n", def, csr_builddeftostr(def));
}
return err;
}
static int cmd_memtypes(int transport, int argc, char *argv[])
{
uint8_t array[8];
uint16_t type, stores[4] = { 0x0001, 0x0002, 0x0004, 0x0008 };
int i, err;
OPT_HELP(0, NULL);
for (i = 0; i < 4; i++) {
memset(array, 0, sizeof(array));
array[0] = stores[i] & 0xff;
array[1] = stores[i] >> 8;
err = transport_read(transport, CSR_VARID_PS_MEMORY_TYPE, array, 8);
if (err < 0)
continue;
type = array[2] + (array[3] << 8);
printf("%s (0x%04x) = %s (%d)\n", storestostr(stores[i]),
stores[i], memorytostr(type), type);
}
return 0;
}
BOOL nego_recv_response(rdpNego* nego)
{
int status;
wStream* s;
s = Stream_New(NULL, 1024);
status = transport_read(nego->transport, s);
if (status < 0)
{
Stream_Free(s, TRUE);
return FALSE;
}
status = nego_recv(nego->transport, s, nego);
if (status < 0)
{
Stream_Free(s, TRUE);
return FALSE;
}
return TRUE;
}
boolean nego_recv_response(rdpNego* nego)
{
STREAM* s = transport_recv_stream_init(nego->transport, 1024);
if (transport_read(nego->transport, s) < 0)
return false;
return nego_recv(nego->transport, s, nego->transport->recv_extra);
}
static int cmd_chiprev(int transport, int argc, char *argv[])
{
uint8_t array[8];
uint16_t rev;
char *str;
int err;
OPT_HELP(0, NULL);
memset(array, 0, sizeof(array));
err = transport_read(transport, CSR_VARID_CHIPREV, array, 8);
if (err < 0) {
errno = -err;
return -1;
}
rev = array[0] | (array[1] << 8);
switch (rev) {
case 0x64:
str = "BC1 ES";
break;
case 0x65:
str = "BC1";
break;
case 0x89:
str = "BC2-External A";
break;
case 0x8a:
str = "BC2-External B";
break;
case 0x28:
str = "BC2-ROM";
break;
case 0x43:
str = "BC3-Multimedia";
break;
case 0x15:
str = "BC3-ROM";
break;
case 0xe2:
str = "BC3-Flash";
break;
case 0x26:
str = "BC4-External";
break;
case 0x30:
str = "BC4-ROM";
break;
default:
str = "NA";
break;
}
printf("Chip revision: 0x%04x (%s)\n", rev, str);
return 0;
}
BOOL nego_recv_response(rdpNego* nego)
{
STREAM* s = transport_recv_stream_init(nego->transport, 1024);
if (transport_read(nego->transport, s) < 0)
return FALSE;
return nego_recv(nego->transport, s, nego);
}
void rdp_recv(rdpRdp* rdp)
{
STREAM* s;
s = transport_recv_stream_init(rdp->transport, 4096);
transport_read(rdp->transport, s);
rdp_recv_pdu(rdp, s);
}
static int cmd_pslist(int transport, int argc, char *argv[])
{
uint8_t array[8];
uint16_t pskey = 0x0000, length, stores = CSR_STORES_DEFAULT;
int err, reset = 0;
OPT_PSKEY(0, &stores, &reset, NULL);
while (1) {
memset(array, 0, sizeof(array));
array[0] = pskey & 0xff;
array[1] = pskey >> 8;
array[2] = stores & 0xff;
array[3] = stores >> 8;
err = transport_read(transport, CSR_VARID_PS_NEXT, array, 8);
if (err < 0)
break;
pskey = array[4] + (array[5] << 8);
if (pskey == 0x0000)
break;
memset(array, 0, sizeof(array));
array[0] = pskey & 0xff;
array[1] = pskey >> 8;
array[2] = stores & 0xff;
array[3] = stores >> 8;
err = transport_read(transport, CSR_VARID_PS_SIZE, array, 8);
if (err < 0)
continue;
length = array[2] + (array[3] << 8);
printf("0x%04x - %s (%d bytes)\n", pskey,
csr_pskeytostr(pskey), length * 2);
}
if (reset)
transport_write(transport, CSR_VARID_WARM_RESET, NULL, 0);
return 0;
}
static int transport_read_nonblocking(rdpTransport* transport)
{
int status;
status = transport_read(transport, transport->ReceiveBuffer);
if (status <= 0)
return status;
Stream_Seek(transport->ReceiveBuffer, status);
return status;
}
static int transport_read_nonblocking(rdpTransport* transport)
{
int status;
stream_check_size(transport->recv_buffer, 4096);
status = transport_read(transport, transport->recv_buffer);
if (status <= 0)
return status;
stream_seek(transport->recv_buffer, status);
return status;
}
static int transport_read_nonblocking(rdpTransport* transport)
{
int status;
stream_check_size(transport->ReceiveBuffer, 32 * 1024);
status = transport_read(transport, transport->ReceiveBuffer);
if (status <= 0)
return status;
stream_seek(transport->ReceiveBuffer, status);
return status;
}
int credssp_recv(rdpCredssp* credssp, rdpBlob* negoToken, rdpBlob* authInfo, rdpBlob* pubKeyAuth)
{
STREAM* s;
int length;
int status;
uint32 version;
s = transport_recv_stream_init(credssp->transport, 2048);
status = transport_read(credssp->transport, s);
if (status < 0)
return -1;
/* TSRequest */
ber_read_sequence_tag(s, &length);
ber_read_contextual_tag(s, 0, &length, True);
ber_read_integer(s, &version);
/* [1] negoTokens (NegoData) */
if (ber_read_contextual_tag(s, 1, &length, True) != False)
{
ber_read_sequence_tag(s, &length); /* SEQUENCE OF NegoDataItem */
ber_read_sequence_tag(s, &length); /* NegoDataItem */
ber_read_contextual_tag(s, 0, &length, True); /* [0] negoToken */
ber_read_octet_string(s, &length); /* OCTET STRING */
freerdp_blob_alloc(negoToken, length);
stream_read(s, negoToken->data, length);
}
/* [2] authInfo (OCTET STRING) */
if (ber_read_contextual_tag(s, 2, &length, True) != False)
{
ber_read_octet_string(s, &length); /* OCTET STRING */
freerdp_blob_alloc(authInfo, length);
stream_read(s, authInfo->data, length);
}
/* [3] pubKeyAuth (OCTET STRING) */
if (ber_read_contextual_tag(s, 3, &length, True) != False)
{
ber_read_octet_string(s, &length); /* OCTET STRING */
freerdp_blob_alloc(pubKeyAuth, length);
stream_read(s, pubKeyAuth->data, length);
}
return 0;
}
static int cmd_rand(int transport, int argc, char *argv[])
{
uint8_t array[8];
uint16_t rand;
int err;
OPT_HELP(0, NULL);
memset(array, 0, sizeof(array));
err = transport_read(transport, CSR_VARID_RAND, array, 8);
if (err < 0)
return -1;
rand = array[0] | (array[1] << 8);
printf("Random number: 0x%02x (%d)\n", rand, rand);
return 0;
}
static int cmd_clock(int transport, int argc, char *argv[])
{
uint8_t array[8];
uint32_t clock;
int err;
OPT_HELP(0, NULL);
memset(array, 0, sizeof(array));
err = transport_read(transport, CSR_VARID_BT_CLOCK, array, 8);
if (err < 0)
return -1;
clock = array[2] | (array[3] << 8) | (array[0] << 16) | (array[1] << 24);
printf("Bluetooth clock: 0x%04x (%d)\n", clock, clock);
return 0;
}
static int cmd_faultarg(int transport, int argc, char *argv[])
{
uint8_t array[8];
uint16_t error;
int err;
OPT_HELP(0, NULL);
memset(array, 0, sizeof(array));
err = transport_read(transport, CSR_VARID_FAULT_ARG, array, 8);
if (err < 0)
return -1;
error = array[0] | (array[1] << 8);
printf("Fault code: 0x%02x (%s)\n", error,
error < 0x100 ? "valid" : "invalid");
return 0;
}
static int cmd_buildname(int transport, int argc, char *argv[])
{
uint8_t array[130];
char name[64];
unsigned int i;
int err;
OPT_HELP(0, NULL);
memset(array, 0, sizeof(array));
err = transport_read(transport, CSR_VARID_READ_BUILD_NAME, array, 128);
if (err < 0)
return -1;
for (i = 0; i < sizeof(name); i++)
name[i] = array[(i * 2) + 4];
printf("Build name: %s\n", name);
return 0;
}
static int cmd_psread(int transport, int argc, char *argv[])
{
uint8_t array[256];
uint16_t pskey = 0x0000, length, stores = CSR_STORES_DEFAULT;
char *str, val[7];
int i, err, reset = 0;
OPT_PSKEY(0, &stores, &reset, NULL);
while (1) {
memset(array, 0, sizeof(array));
array[0] = pskey & 0xff;
array[1] = pskey >> 8;
array[2] = stores & 0xff;
array[3] = stores >> 8;
err = transport_read(transport, CSR_VARID_PS_NEXT, array, 8);
if (err < 0)
break;
pskey = array[4] + (array[5] << 8);
if (pskey == 0x0000)
break;
memset(array, 0, sizeof(array));
array[0] = pskey & 0xff;
array[1] = pskey >> 8;
array[2] = stores & 0xff;
array[3] = stores >> 8;
err = transport_read(transport, CSR_VARID_PS_SIZE, array, 8);
if (err < 0)
continue;
length = array[2] + (array[3] << 8);
if (length + 6 > sizeof(array) / 2)
continue;
memset(array, 0, sizeof(array));
array[0] = pskey & 0xff;
array[1] = pskey >> 8;
array[2] = length & 0xff;
array[3] = length >> 8;
array[4] = stores & 0xff;
array[5] = stores >> 8;
err = transport_read(transport, CSR_VARID_PS, array, (length + 3) * 2);
if (err < 0)
continue;
str = csr_pskeytoval(pskey);
if (!strcasecmp(str, "UNKNOWN")) {
sprintf(val, "0x%04x", pskey);
str = NULL;
}
printf("// %s%s\n&%04x =", str ? "PSKEY_" : "",
str ? str : val, pskey);
for (i = 0; i < length; i++)
printf(" %02x%02x", array[(i * 2) + 7], array[(i * 2) + 6]);
printf("\n");
}
if (reset)
transport_write(transport, CSR_VARID_WARM_RESET, NULL, 0);
return 0;
}
static int cmd_psset(int transport, int argc, char *argv[])
{
uint8_t array[128];
uint16_t pskey, length, value, stores = CSR_STORES_PSRAM;
uint32_t val32;
int i, err, reset = 0;
memset(array, 0, sizeof(array));
OPT_PSKEY(2, &stores, &reset, NULL);
if (strncasecmp(argv[0], "0x", 2)) {
pskey = atoi(argv[0]);
for (i = 0; storage[i].pskey; i++) {
if (strcasecmp(storage[i].str, argv[0]))
continue;
pskey = storage[i].pskey;
break;
}
} else
pskey = strtol(argv[0] + 2, NULL, 16);
memset(array, 0, sizeof(array));
array[0] = pskey & 0xff;
array[1] = pskey >> 8;
array[2] = stores & 0xff;
array[3] = stores >> 8;
err = transport_read(transport, CSR_VARID_PS_SIZE, array, 8);
if (err < 0)
return err;
length = array[2] + (array[3] << 8);
if (length + 6 > sizeof(array) / 2)
return -EIO;
memset(array, 0, sizeof(array));
array[0] = pskey & 0xff;
array[1] = pskey >> 8;
array[2] = length & 0xff;
array[3] = length >> 8;
array[4] = stores & 0xff;
array[5] = stores >> 8;
argc--;
argv++;
switch (length) {
case 1:
if (argc != 1) {
errno = E2BIG;
return -1;
}
if (!strncasecmp(argv[0], "0x", 2))
value = strtol(argv[0] + 2, NULL, 16);
else
value = atoi(argv[0]);
array[6] = value & 0xff;
array[7] = value >> 8;
break;
case 2:
if (argc != 1) {
errno = E2BIG;
return -1;
}
if (!strncasecmp(argv[0], "0x", 2))
val32 = strtol(argv[0] + 2, NULL, 16);
else
val32 = atoi(argv[0]);
array[6] = (val32 & 0xff0000) >> 16;
array[7] = val32 >> 24;
array[8] = val32 & 0xff;
array[9] = (val32 & 0xff00) >> 8;
break;
default:
if (argc != length * 2) {
errno = EINVAL;
return -1;
}
for (i = 0; i < length * 2; i++)
if (!strncasecmp(argv[0], "0x", 2))
array[i + 6] = strtol(argv[i] + 2, NULL, 16);
else
array[i + 6] = atoi(argv[i]);
break;
}
err = transport_write(transport, CSR_VARID_PS, array, (length + 3) * 2);
if (err < 0)
return err;
if (reset)
transport_write(transport, CSR_VARID_WARM_RESET, NULL, 0);
return err;
}
static int cmd_psget(int transport, int argc, char *argv[])
{
uint8_t array[128];
uint16_t pskey, length, value, stores = CSR_STORES_DEFAULT;
uint32_t val32;
int i, err, reset = 0;
memset(array, 0, sizeof(array));
OPT_PSKEY(1, &stores, &reset, NULL);
if (strncasecmp(argv[0], "0x", 2)) {
pskey = atoi(argv[0]);
for (i = 0; storage[i].pskey; i++) {
if (strcasecmp(storage[i].str, argv[0]))
continue;
pskey = storage[i].pskey;
break;
}
} else
pskey = strtol(argv[0] + 2, NULL, 16);
memset(array, 0, sizeof(array));
array[0] = pskey & 0xff;
array[1] = pskey >> 8;
array[2] = stores & 0xff;
array[3] = stores >> 8;
err = transport_read(transport, CSR_VARID_PS_SIZE, array, 8);
if (err < 0)
return err;
length = array[2] + (array[3] << 8);
if (length + 6 > sizeof(array) / 2)
return -EIO;
memset(array, 0, sizeof(array));
array[0] = pskey & 0xff;
array[1] = pskey >> 8;
array[2] = length & 0xff;
array[3] = length >> 8;
array[4] = stores & 0xff;
array[5] = stores >> 8;
err = transport_read(transport, CSR_VARID_PS, array, (length + 3) * 2);
if (err < 0)
return err;
switch (length) {
case 1:
value = array[6] | (array[7] << 8);
printf("%s: 0x%04x (%d)\n", csr_pskeytostr(pskey), value, value);
break;
case 2:
val32 = array[8] | (array[9] << 8) | (array[6] << 16) | (array[7] << 24);
printf("%s: 0x%08x (%d)\n", csr_pskeytostr(pskey), val32, val32);
break;
default:
printf("%s:", csr_pskeytostr(pskey));
for (i = 0; i < length; i++)
printf(" 0x%02x%02x", array[(i * 2) + 6], array[(i * 2) + 7]);
printf("\n");
break;
}
if (reset)
transport_write(transport, CSR_VARID_WARM_RESET, NULL, 0);
return err;
}
/**
* Perform a SWD I/O operation.
*
* @note This function must only be used if the #JAYLINK_TIF_SWD interface is
* available and selected.
*
* @param[in,out] devh Device handle.
* @param[in] direction Buffer to read the transfer direction from.
* @param[in] out Buffer to read host-to-target data from.
* @param[out] in Buffer to store target-to-host data on success. Its content
* is undefined on failure. The buffer must be large enough to
* contain at least the specified number of bits to transfer.
* @param[in] length Total number of bits to transfer from host to target and
* vice versa.
*
* @retval JAYLINK_OK Success.
* @retval JAYLINK_ERR_ARG Invalid arguments.
* @retval JAYLINK_ERR_TIMEOUT A timeout occurred.
* @retval JAYLINK_ERR_DEV Unspecified device error.
* @retval JAYLINK_ERR_DEV_NO_MEMORY Not enough memory on the device to perform
* the operation.
* @retval JAYLINK_ERR Other error conditions.
*
* @see jaylink_select_interface()
* @see jaylink_set_speed()
*
* @since 0.1.0
*/
JAYLINK_API int jaylink_swd_io(struct jaylink_device_handle *devh,
const uint8_t *direction, const uint8_t *out, uint8_t *in,
uint16_t length)
{
int ret;
struct jaylink_context *ctx;
uint16_t num_bytes;
uint8_t buf[4];
uint8_t status;
if (!devh || !direction || !out || !in || !length)
return JAYLINK_ERR_ARG;
ctx = devh->dev->ctx;
num_bytes = (length + 7) / 8;
ret = transport_start_write_read(devh, 4 + 2 * num_bytes,
num_bytes + 1, true);
if (ret != JAYLINK_OK) {
log_err(ctx, "transport_start_write_read() failed: %s.",
jaylink_strerror(ret));
return ret;
}
buf[0] = CMD_SWD_IO;
buf[1] = 0x00;
buffer_set_u16(buf, length, 2);
ret = transport_write(devh, buf, 4);
if (ret != JAYLINK_OK) {
log_err(ctx, "transport_write() failed: %s.",
jaylink_strerror(ret));
return ret;
}
ret = transport_write(devh, direction, num_bytes);
if (ret != JAYLINK_OK) {
log_err(ctx, "transport_write() failed: %s.",
jaylink_strerror(ret));
return ret;
}
ret = transport_write(devh, out, num_bytes);
if (ret != JAYLINK_OK) {
log_err(ctx, "transport_write() failed: %s.",
jaylink_strerror(ret));
return ret;
}
ret = transport_read(devh, in, num_bytes);
if (ret != JAYLINK_OK) {
log_err(ctx, "transport_read() failed: %s.",
jaylink_strerror(ret));
return ret;
}
ret = transport_read(devh, &status, 1);
if (ret != JAYLINK_OK) {
log_err(ctx, "transport_read() failed: %s.",
jaylink_strerror(ret));
return ret;
}
if (status == SWD_IO_ERR_NO_MEMORY) {
return JAYLINK_ERR_DEV_NO_MEMORY;
} else if (status > 0) {
log_err(ctx, "SWD I/O operation failed: %02x.", status);
return JAYLINK_ERR_DEV;
}
return JAYLINK_OK;
}
int
main(int argc, char *argv[])
{
int sockfd, ret;
char *ret_str;
struct sockaddr_in servaddr;
SearpcClient *rpc_client;
GError *error = NULL;
TcpTransport *transport;
#if !GLIB_CHECK_VERSION(2, 36, 0)
g_type_init();
#endif
#ifdef WIN32
WSADATA wsadata;
WSAStartup(0x0101, &wsadata);
#endif
ret = sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (ret < 0) {
fprintf(stderr, "socket failed: %s\n", strerror(errno));
exit(-1);
}
int on = 1;
if (setsockopt (sockfd, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof(on)) < 0) {
fprintf (stderr, "setsockopt of SO_REUSEADDR error: %s\n", strerror(errno));
exit(-1);
}
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(12345);
inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
ret = connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
if (ret < 0) {
fprintf(stderr, "connect failed: %s\n", strerror(errno));
exit(-1);
}
transport = g_new0 (TcpTransport, 1);
transport->fd = sockfd;
/* create an rpc_client and supply the transport function. */
rpc_client = searpc_client_new();
rpc_client->async_send = transport_send;
rpc_client->async_arg = (void *)(long)transport;
/* call the client-side funcion */
searpc_client_async_call__int(rpc_client, "searpc_strlen",
strlen_callback, "user data",
1, "string", "hello searpc");
/* call the transport to receive response */
transport_read (transport);
if (error != NULL) {
fprintf(stderr, "error: %s\n", error->message);
exit(-1);
}
close(sockfd);
return 0;
}
int credssp_recv(rdpCredssp* credssp)
{
STREAM* s;
int length;
int status;
UINT32 version;
s = stream_new(4096);
status = transport_read(credssp->transport, s);
s->size = status;
if (status < 0)
{
printf("credssp_recv() error: %d\n", status);
stream_free(s);
return -1;
}
/* TSRequest */
if(!ber_read_sequence_tag(s, &length) ||
!ber_read_contextual_tag(s, 0, &length, TRUE) ||
!ber_read_integer(s, &version))
return -1;
/* [1] negoTokens (NegoData) */
if (ber_read_contextual_tag(s, 1, &length, TRUE) != FALSE)
{
if (!ber_read_sequence_tag(s, &length) || /* SEQUENCE OF NegoDataItem */
!ber_read_sequence_tag(s, &length) || /* NegoDataItem */
!ber_read_contextual_tag(s, 0, &length, TRUE) || /* [0] negoToken */
!ber_read_octet_string_tag(s, &length) || /* OCTET STRING */
stream_get_left(s) < length)
return -1;
sspi_SecBufferAlloc(&credssp->negoToken, length);
stream_read(s, credssp->negoToken.pvBuffer, length);
credssp->negoToken.cbBuffer = length;
}
/* [2] authInfo (OCTET STRING) */
if (ber_read_contextual_tag(s, 2, &length, TRUE) != FALSE)
{
if(!ber_read_octet_string_tag(s, &length) || /* OCTET STRING */
stream_get_left(s) < length)
return -1;
sspi_SecBufferAlloc(&credssp->authInfo, length);
stream_read(s, credssp->authInfo.pvBuffer, length);
credssp->authInfo.cbBuffer = length;
}
/* [3] pubKeyAuth (OCTET STRING) */
if (ber_read_contextual_tag(s, 3, &length, TRUE) != FALSE)
{
if(!ber_read_octet_string_tag(s, &length) || /* OCTET STRING */
stream_get_left(s) < length)
return -1;
sspi_SecBufferAlloc(&credssp->pubKeyAuth, length);
stream_read(s, credssp->pubKeyAuth.pvBuffer, length);
credssp->pubKeyAuth.cbBuffer = length;
}
stream_free(s);
return 0;
}
void rdp_recv(rdpRdp* rdp)
{
STREAM* s;
int length;
uint16 pduType;
uint16 pduLength;
uint16 initiator;
uint16 channelId;
uint16 sec_flags;
enum DomainMCSPDU MCSPDU;
s = transport_recv_stream_init(rdp->transport, 4096);
transport_read(rdp->transport, s);
MCSPDU = DomainMCSPDU_SendDataIndication;
mcs_read_domain_mcspdu_header(s, &MCSPDU, &length);
per_read_integer16(s, &initiator, MCS_BASE_CHANNEL_ID); /* initiator (UserId) */
per_read_integer16(s, &channelId, 0); /* channelId */
stream_seek(s, 1); /* dataPriority + Segmentation (0x70) */
per_read_length(s, &pduLength); /* userData (OCTET_STRING) */
if (rdp->connected != True)
{
rdp_read_security_header(s, &sec_flags);
if (sec_flags & SEC_PKT_MASK)
{
switch (sec_flags & SEC_PKT_MASK)
{
case SEC_LICENSE_PKT:
license_recv(rdp->license, s);
break;
case SEC_REDIRECTION_PKT:
rdp_read_redirection_packet(rdp, s);
break;
default:
printf("incorrect security flags: 0x%04X\n", sec_flags);
break;
}
}
}
else
{
rdp_read_share_control_header(s, &pduLength, &pduType, &rdp->settings->pdu_source);
switch (pduType)
{
case PDU_TYPE_DATA:
rdp_read_data_pdu(rdp, s);
break;
case PDU_TYPE_DEMAND_ACTIVE:
rdp_recv_demand_active(rdp, s, rdp->settings);
break;
case PDU_TYPE_DEACTIVATE_ALL:
rdp_read_deactivate_all(s, rdp->settings);
break;
case PDU_TYPE_SERVER_REDIRECTION:
rdp_read_enhanced_security_redirection_packet(rdp, s);
break;
default:
printf("incorrect PDU type: 0x%04X\n", pduType);
break;
}
}
}
int transport_delay(rdpTransport* transport, STREAM* s)
{
transport_read(transport, s);
nanosleep(&transport->ts, NULL);
return 0;
}
int credssp_recv(rdpCredssp* credssp)
{
wStream* s;
int length;
int status;
UINT32 version;
s = Stream_New(NULL, 4096);
status = transport_read(credssp->transport, s);
Stream_Length(s) = status;
if (status < 0)
{
fprintf(stderr, "credssp_recv() error: %d\n", status);
Stream_Free(s, TRUE);
return -1;
}
/* TSRequest */
if(!ber_read_sequence_tag(s, &length) ||
!ber_read_contextual_tag(s, 0, &length, TRUE) ||
!ber_read_integer(s, &version))
{
Stream_Free(s, TRUE);
return -1;
}
/* [1] negoTokens (NegoData) */
if (ber_read_contextual_tag(s, 1, &length, TRUE) != FALSE)
{
if (!ber_read_sequence_tag(s, &length) || /* SEQUENCE OF NegoDataItem */
!ber_read_sequence_tag(s, &length) || /* NegoDataItem */
!ber_read_contextual_tag(s, 0, &length, TRUE) || /* [0] negoToken */
!ber_read_octet_string_tag(s, &length) || /* OCTET STRING */
Stream_GetRemainingLength(s) < length)
{
Stream_Free(s, TRUE);
return -1;
}
sspi_SecBufferAlloc(&credssp->negoToken, length);
Stream_Read(s, credssp->negoToken.pvBuffer, length);
credssp->negoToken.cbBuffer = length;
}
/* [2] authInfo (OCTET STRING) */
if (ber_read_contextual_tag(s, 2, &length, TRUE) != FALSE)
{
if(!ber_read_octet_string_tag(s, &length) || /* OCTET STRING */
Stream_GetRemainingLength(s) < length)
{
Stream_Free(s, TRUE);
return -1;
}
sspi_SecBufferAlloc(&credssp->authInfo, length);
Stream_Read(s, credssp->authInfo.pvBuffer, length);
credssp->authInfo.cbBuffer = length;
}
/* [3] pubKeyAuth (OCTET STRING) */
if (ber_read_contextual_tag(s, 3, &length, TRUE) != FALSE)
{
if(!ber_read_octet_string_tag(s, &length) || /* OCTET STRING */
Stream_GetRemainingLength(s) < length)
{
Stream_Free(s, TRUE);
return -1;
}
sspi_SecBufferAlloc(&credssp->pubKeyAuth, length);
Stream_Read(s, credssp->pubKeyAuth.pvBuffer, length);
credssp->pubKeyAuth.cbBuffer = length;
}
Stream_Free(s, TRUE);
return 0;
}
