void run_test_ok_data(void)
{
MCSPacket *pkt_wr, *pkt_rd;
unsigned char data[] = "Hello World!";
bool error = false;
start_test();
abs_test_printf("Testing command OK_DATA\n");
pkt_wr = mcs_ok_packet_data(data, strlen((char *)data));
if(pkt_wr != NULL) {
if(mcs_write_command_and_free(pkt_wr, pipe_fd[1]) < 0) {
abs_test_printf("mcs_write_command returned a wrong value\n");
error = true;
} else {
pkt_rd = mcs_read_command(pipe_fd[0], pipe_fd[1]);
error = !mcs_cmp(pkt_wr, pkt_rd);
mcs_free(pkt_rd);
}
} else {
error = true;
}
end_test();
if(error) {
abs_test_add_result(FAIL, "TYPE_OK_DATA");
} else {
abs_test_add_result(PASS, "TYPE_OK_DATA");
}
}
boolean rdp_client_redirect(rdpRdp* rdp)
{
rdpSettings* settings = rdp->settings;
rdpRedirection* redirection = rdp->redirection;
rdp_client_disconnect(rdp);
mcs_free(rdp->mcs);
nego_free(rdp->nego);
license_free(rdp->license);
transport_free(rdp->transport);
rdp->transport = transport_new(settings);
rdp->license = license_new(rdp);
rdp->nego = nego_new(rdp->transport);
rdp->mcs = mcs_new(rdp->transport);
rdp->transport->layer = TRANSPORT_LAYER_TCP;
settings->redirected_session_id = redirection->sessionID;
if (redirection->flags & LB_LOAD_BALANCE_INFO)
nego_set_routing_token(rdp->nego, &redirection->loadBalanceInfo);
if (redirection->flags & LB_TARGET_NET_ADDRESS)
settings->hostname = redirection->targetNetAddress.ascii;
else if (redirection->flags & LB_TARGET_NETBIOS_NAME)
settings->hostname = redirection->targetNetBiosName.ascii;
if (redirection->flags & LB_USERNAME)
settings->username = redirection->username.ascii;
if (redirection->flags & LB_DOMAIN)
settings->domain = redirection->domain.ascii;
return rdp_client_connect(rdp);
}
void rdp_free(rdpRdp* rdp)
{
if (rdp)
{
crypto_rc4_free(rdp->rc4_decrypt_key);
crypto_rc4_free(rdp->rc4_encrypt_key);
crypto_des3_free(rdp->fips_encrypt);
crypto_des3_free(rdp->fips_decrypt);
crypto_hmac_free(rdp->fips_hmac);
freerdp_settings_free(rdp->settings);
freerdp_settings_free(rdp->settingsCopy);
transport_free(rdp->transport);
license_free(rdp->license);
input_free(rdp->input);
update_free(rdp->update);
fastpath_free(rdp->fastpath);
nego_free(rdp->nego);
mcs_free(rdp->mcs);
redirection_free(rdp->redirection);
autodetect_free(rdp->autodetect);
heartbeat_free(rdp->heartbeat);
multitransport_free(rdp->multitransport);
bulk_free(rdp->bulk);
free(rdp);
}
}
BOOL rdp_client_reconnect(rdpRdp* rdp)
{
UINT32 i;
transport_disconnect(rdp->transport);
mcs_free(rdp->mcs);
nego_free(rdp->nego);
license_free(rdp->license);
transport_free(rdp->transport);
/* Reset virtual channel status */
for (i = 0; i < rdp->mcs->channelCount; i++)
{
rdp->mcs->channels[i].joined = FALSE;
}
rdp->transport = transport_new(rdp->settings);
rdp->license = license_new(rdp);
rdp->nego = nego_new(rdp->transport);
rdp->mcs = mcs_new(rdp->transport);
rdp->transport->layer = TRANSPORT_LAYER_TCP;
return rdp_client_connect(rdp);
}
void run_test_ok(void)
{
MCSPacket *pkt_wr, *pkt_rd;
bool error = false;
start_test();
abs_test_printf("Testing command OK\n");
pkt_wr = mcs_ok_packet();
if(pkt_wr != NULL) {
if(mcs_write_command_and_free(pkt_wr, pipe_fd[1]) < 0) {
abs_test_printf("mcs_write_command returned a wrong value\n");
error = true;
} else {
pkt_rd = mcs_read_command(pipe_fd[0], pipe_fd[1]);
error = !mcs_cmp(pkt_wr, pkt_rd);
mcs_free(pkt_rd);
}
} else {
error = EUNDEF;
}
end_test();
if(error) {
abs_test_add_result(FAIL, "TYPE_OK");
} else {
abs_test_add_result(PASS, "TYPE_OK");
}
}
mcs_st *lmc_create(mcs_st *ptr, const char *config) {
assert(ptr);
memset(ptr, 0, sizeof(*ptr));
ptr->kind = MCS_KIND_LIBMEMCACHED;
memcached_st *mst = memcached_create(NULL);
if (mst != NULL) {
memcached_behavior_set(mst, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);
memcached_behavior_set(mst, MEMCACHED_BEHAVIOR_KETAMA, 1);
memcached_behavior_set(mst, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
memcached_server_st *mservers;
mservers = memcached_servers_parse(config);
if (mservers != NULL) {
memcached_server_push(mst, mservers);
ptr->data = mst;
ptr->nservers = (int) memcached_server_list_count(mservers);
if (ptr->nservers > 0) {
ptr->servers = calloc(sizeof(mcs_server_st), ptr->nservers);
if (ptr->servers != NULL) {
for (int i = 0; i < ptr->nservers; i++) {
ptr->servers[i].fd = -1;
}
int j = 0;
for (; j < ptr->nservers; j++) {
strncpy(ptr->servers[j].hostname,
memcached_server_name(mservers + j),
sizeof(ptr->servers[j].hostname) - 1);
ptr->servers[j].port = (int) memcached_server_port(mservers + j);
if (ptr->servers[j].port <= 0) {
moxi_log_write("lmc_create failed, could not parse port: %s\n",
config);
break;
}
}
if (j >= ptr->nservers) {
memcached_server_list_free(mservers);
return ptr;
}
}
}
memcached_server_list_free(mservers);
}
}
mcs_free(ptr);
return NULL;
}
void rdp_free(rdpRdp* rdp)
{
if (rdp != NULL)
{
settings_free(rdp->settings);
transport_free(rdp->transport);
license_free(rdp->license);
mcs_free(rdp->mcs);
xfree(rdp);
}
}
void rdp_free(rdpRdp* rdp)
{
if (rdp != NULL)
{
settings_free(rdp->settings);
transport_free(rdp->transport);
license_free(rdp->license);
input_free(rdp->input);
update_free(rdp->update);
fastpath_free(rdp->fastpath);
nego_free(rdp->nego);
mcs_free(rdp->mcs);
redirection_free(rdp->redirection);
mppc_free(rdp);
xfree(rdp);
}
}
void rdp_free(rdpRdp* rdp)
{
if (rdp != NULL)
{
crypto_rc4_free(rdp->rc4_decrypt_key);
crypto_rc4_free(rdp->rc4_encrypt_key);
crypto_des3_free(rdp->fips_encrypt);
crypto_des3_free(rdp->fips_decrypt);
crypto_hmac_free(rdp->fips_hmac);
settings_free(rdp->settings);
transport_free(rdp->transport);
license_free(rdp->license);
// input_free(rdp->input);
// update_free(rdp->update);
fastpath_free(rdp->fastpath);
nego_free(rdp->nego);
mcs_free(rdp->mcs);
redirection_free(rdp->redirection);
mppc_free(rdp);
xfree(rdp);
}
}
void rdp_reset(rdpRdp* rdp)
{
rdpSettings* settings;
settings = rdp->settings;
bulk_reset(rdp->bulk);
crypto_rc4_free(rdp->rc4_decrypt_key);
rdp->rc4_decrypt_key = NULL;
crypto_rc4_free(rdp->rc4_encrypt_key);
rdp->rc4_encrypt_key = NULL;
crypto_des3_free(rdp->fips_encrypt);
rdp->fips_encrypt = NULL;
crypto_des3_free(rdp->fips_decrypt);
rdp->fips_decrypt = NULL;
crypto_hmac_free(rdp->fips_hmac);
rdp->fips_hmac = NULL;
mcs_free(rdp->mcs);
nego_free(rdp->nego);
license_free(rdp->license);
transport_free(rdp->transport);
free(settings->ServerRandom);
settings->ServerRandom = NULL;
free(settings->ServerCertificate);
settings->ServerCertificate = NULL;
free(settings->ClientAddress);
settings->ClientAddress = NULL;
rdp->transport = transport_new(rdp->settings);
rdp->transport->rdp = rdp;
rdp->license = license_new(rdp);
rdp->nego = nego_new(rdp->transport);
rdp->mcs = mcs_new(rdp->transport);
rdp->transport->layer = TRANSPORT_LAYER_TCP;
}
rdpRdp* rdp_new(rdpContext* context)
{
rdpRdp* rdp;
DWORD flags;
BOOL newSettings = FALSE;
rdp = (rdpRdp*) calloc(1, sizeof(rdpRdp));
if (!rdp)
return NULL;
rdp->context = context;
rdp->instance = context->instance;
flags = 0;
if (context->ServerMode)
flags |= FREERDP_SETTINGS_SERVER_MODE;
if (!context->settings)
{
context->settings = freerdp_settings_new(flags);
if (!context->settings)
goto out_free;
newSettings = TRUE;
}
rdp->settings = context->settings;
rdp->settings->instance = context->instance;
if (context->instance)
context->instance->settings = rdp->settings;
rdp->transport = transport_new(rdp->settings);
if (!rdp->transport)
goto out_free_settings;
rdp->transport->rdp = rdp;
rdp->license = license_new(rdp);
if (!rdp->license)
goto out_free_transport;
rdp->input = input_new(rdp);
if (!rdp->input)
goto out_free_license;
rdp->update = update_new(rdp);
if (!rdp->update)
goto out_free_input;
rdp->fastpath = fastpath_new(rdp);
if (!rdp->fastpath)
goto out_free_update;
rdp->nego = nego_new(rdp->transport);
if (!rdp->nego)
goto out_free_fastpath;
rdp->mcs = mcs_new(rdp->transport);
if (!rdp->mcs)
goto out_free_nego;
rdp->redirection = redirection_new();
if (!rdp->redirection)
goto out_free_mcs;
rdp->autodetect = autodetect_new();
if (!rdp->autodetect)
goto out_free_redirection;
rdp->heartbeat = heartbeat_new();
if (!rdp->heartbeat)
goto out_free_autodetect;
rdp->multitransport = multitransport_new();
if (!rdp->multitransport)
goto out_free_heartbeat;
rdp->bulk = bulk_new(context);
if (!rdp->bulk)
goto out_free_multitransport;
return rdp;
out_free_multitransport:
multitransport_free(rdp->multitransport);
out_free_heartbeat:
heartbeat_free(rdp->heartbeat);
out_free_autodetect:
autodetect_free(rdp->autodetect);
out_free_redirection:
redirection_free(rdp->redirection);
out_free_mcs:
mcs_free(rdp->mcs);
out_free_nego:
nego_free(rdp->nego);
out_free_fastpath:
fastpath_free(rdp->fastpath);
out_free_update:
update_free(rdp->update);
out_free_input:
input_free(rdp->input);
out_free_license:
license_free(rdp->license);
out_free_transport:
transport_free(rdp->transport);
out_free_settings:
if (newSettings)
freerdp_settings_free(rdp->settings);
out_free:
free(rdp);
return NULL;
}
void run_test(enum MCSType type)
{
const MCSCommandOptionsCommon *cmd;
MCSPacket *pkt_wr, *pkt_rd;
unsigned char *args;
unsigned char data[] = "Hello World!";
int i, j;
bool error = false;
for(i = 0; i < mcs_command_list_size[type]; ++i) {
start_test();
if(type == MCS_TYPE_MESSAGE) {
cmd = &mcs_command_message_list[i].cmd;
} else if(type == MCS_TYPE_STATE) {
cmd = &mcs_command_state_list[i].cmd;
} else if(type == MCS_TYPE_PAYLOAD) {
cmd = &mcs_command_payload_list[i].cmd;
} else {
cmd = NULL;
abs_test_printf("mcs_command_list_size is incorrect for type %d\n",
type);
abs_test_fail_and_exit("MCS Type");
}
abs_test_printf("Testing command %s\n", cmd->name);
if(cmd->nargs == 0) {
args = NULL;
} else {
args = malloc(cmd->nargs);
for(j = 0; j < cmd->nargs; ++j) {
args[j] = j;
}
}
if(type == MCS_TYPE_MESSAGE &&
mcs_command_message_list[i].destination != NULL &&
mcs_command_message_list[i].destination[0] == '@') {
if(cmd->raw_data) {
pkt_wr = mcs_create_packet_with_dest(
(MCSCommand)((int)(type << 16) | i), "test_dest",
cmd->nargs, args, strlen((char *)data), data);
} else {
pkt_wr = mcs_create_packet_with_dest(
(MCSCommand)((int)(type << 16) | i), "test_dest",
cmd->nargs, args, 0, NULL);
}
} else {
if(cmd->raw_data) {
pkt_wr = mcs_create_packet(
(MCSCommand)((int)(type << 16) | i),
cmd->nargs, args, strlen((char *)data), data);
} else {
pkt_wr = mcs_create_packet(
(MCSCommand)((int)(type << 16) | i),
cmd->nargs, args, 0, NULL);
}
}
if(cmd->nargs != 0) {
free(args);
}
if(pkt_wr != NULL) {
if(mcs_write_command(pkt_wr, pipe_fd[1]) < 0) {
abs_test_printf("mcs_write_command returned a wrong value\n");
error = true;
} else {
pkt_rd = mcs_read_command(pipe_fd[0], pipe_fd[1]);
error = !mcs_cmp(pkt_wr, pkt_rd);
mcs_free(pkt_rd);
}
} else {
error = true;
}
mcs_free(pkt_wr);
end_test();
if(error) {
abs_test_add_result(FAIL, cmd->name);
} else {
abs_test_add_result(PASS, cmd->name);
}
}
}
mcs_st *lmc_create(mcs_st *ptr, const char *config,
const char *default_usr,
const char *default_pwd,
const char *opts) {
assert(ptr);
memset(ptr, 0, sizeof(*ptr));
ptr->kind = MCS_KIND_LIBMEMCACHED;
memcached_st *mst = memcached_create(NULL);
if (mst != NULL) {
memcached_behavior_t b = MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED;
uint64_t v = 1;
if (opts != NULL) {
if (strstr(opts, "distribution:ketama-weighted") != NULL) {
b = MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED;
v = 1;
} else if (strstr(opts, "distribution:ketama") != NULL) {
b = MEMCACHED_BEHAVIOR_KETAMA;
v = 1;
} else if (strstr(opts, "distribution:modula") != NULL) {
b = MEMCACHED_BEHAVIOR_KETAMA;
v = 0;
}
}
memcached_behavior_set(mst, b, v);
memcached_behavior_set(mst, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);
memcached_behavior_set(mst, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
memcached_server_st *mservers;
mservers = memcached_servers_parse(config);
if (mservers != NULL) {
memcached_server_push(mst, mservers);
ptr->data = mst;
ptr->nservers = (int) memcached_server_list_count(mservers);
if (ptr->nservers > 0) {
ptr->servers = calloc(sizeof(mcs_server_st), ptr->nservers);
if (ptr->servers != NULL) {
for (int i = 0; i < ptr->nservers; i++) {
ptr->servers[i].fd = -1;
}
int j = 0;
for (; j < ptr->nservers; j++) {
strncpy(ptr->servers[j].hostname,
memcached_server_name(mservers + j),
sizeof(ptr->servers[j].hostname) - 1);
ptr->servers[j].port =
(int) memcached_server_port(mservers + j);
if (ptr->servers[j].port <= 0) {
moxi_log_write("lmc_create failed, could not parse port: %s\n",
config);
break;
}
if (default_usr != NULL) {
ptr->servers[j].usr = strdup(default_usr);
}
if (default_pwd != NULL) {
ptr->servers[j].pwd = strdup(default_pwd);
}
}
if (j >= ptr->nservers) {
memcached_server_list_free(mservers);
return ptr;
}
}
}
memcached_server_list_free(mservers);
}
}
mcs_free(ptr);
return NULL;
}
boolean rdp_client_redirect(rdpRdp* rdp)
{
rdpSettings* settings = rdp->settings;
rdpRedirection* redirection = rdp->redirection;
rdp_client_disconnect(rdp);
/* FIXME: this is a subset of rdp_free */
crypto_rc4_free(rdp->rc4_decrypt_key);
crypto_rc4_free(rdp->rc4_encrypt_key);
crypto_des3_free(rdp->fips_encrypt);
crypto_des3_free(rdp->fips_decrypt);
crypto_hmac_free(rdp->fips_hmac);
mcs_free(rdp->mcs);
nego_free(rdp->nego);
license_free(rdp->license);
transport_free(rdp->transport);
/* FIXME: this is a subset of settings_free */
freerdp_blob_free(settings->server_random);
freerdp_blob_free(settings->server_certificate);
xfree(settings->ip_address);
rdp->transport = transport_new(settings);
rdp->license = license_new(rdp);
rdp->nego = nego_new(rdp->transport);
rdp->mcs = mcs_new(rdp->transport);
rdp->transport->layer = TRANSPORT_LAYER_TCP;
settings->redirected_session_id = redirection->sessionID;
if (redirection->flags & LB_LOAD_BALANCE_INFO)
{
nego_set_routing_token(rdp->nego, &redirection->loadBalanceInfo);
}
else
{
if (redirection->flags & LB_TARGET_NET_ADDRESS)
{
xfree(settings->hostname);
settings->hostname = xstrdup(redirection->targetNetAddress.ascii);
}
else if (redirection->flags & LB_TARGET_FQDN)
{
xfree(settings->hostname);
settings->hostname = xstrdup(redirection->targetFQDN.ascii);
}
else if (redirection->flags & LB_TARGET_NETBIOS_NAME)
{
xfree(settings->hostname);
settings->hostname = xstrdup(redirection->targetNetBiosName.ascii);
}
}
if (redirection->flags & LB_USERNAME)
{
xfree(settings->username);
settings->username = xstrdup(redirection->username.ascii);
}
if (redirection->flags & LB_DOMAIN)
{
xfree(settings->domain);
settings->domain = xstrdup(redirection->domain.ascii);
}
if (redirection->flags & LB_PASSWORD)
{
settings->password_cookie = &redirection->password_cookie;
}
return rdp_client_connect(rdp);
}
/*
* Read a command from a given file descriptor and translate it into a
* MCSPacket
*/
MCSPacket *mcs_read_command(int rfd, int wfd)
{
MCSPacket *pkt;
if(rfd < 0) {
printf_dbg("FD not valid\n");
return NULL;
}
pkt = abs_malloc0(sizeof(*pkt));
if(abs_read(rfd, (char *)&pkt->id, sizeof(pkt->id), MCS_READ_TIMEOUT_US)
< (int)sizeof(pkt->id)) {
printf_dbg("Could not read packet ID\n");
goto error_no_notify;
}
if(abs_read(rfd, (char *)&pkt->type, sizeof(char), MCS_READ_TIMEOUT_US)
< (int)sizeof(char)) {
printf_dbg("Could not read packet type\n");
goto error;
}
switch(pkt->type) {
case MCS_TYPE_MESSAGE:
case MCS_TYPE_STATE:
case MCS_TYPE_PAYLOAD:
if(abs_read(rfd, (char *)&pkt->cmd, sizeof(pkt->cmd),
MCS_READ_TIMEOUT_US) < (int)sizeof(pkt->cmd)) {
printf_dbg("Could not read command\n");
goto error;
}
if(read_check_config(rfd, pkt) < 0) {
goto error;
}
break;
case MCS_TYPE_ERR:
pkt->data_size = sizeof(int);
pkt->data = malloc(pkt->data_size);
if(abs_read(rfd, (char *)pkt->data, pkt->data_size,
MCS_READ_TIMEOUT_US) < pkt->data_size) {
printf_dbg("Could not read error code\n");
goto error;
}
break;
case MCS_TYPE_OK_DATA:
if(abs_read(rfd, (char *)&pkt->data_size, sizeof(pkt->data_size),
MCS_READ_TIMEOUT_US) < (int)sizeof(pkt->data_size)) {
printf_dbg("Could not read raw data size\n");
goto error;
}
pkt->data = malloc(pkt->data_size);
if(abs_read(rfd, (char *)pkt->data, pkt->data_size,
MCS_READ_TIMEOUT_US) < pkt->data_size) {
printf_dbg("Could not read raw data\n");
goto error;
}
break;
case MCS_TYPE_OK:
break;
default:
printf_dbg("Non valid command\n");
goto error;
}
return pkt;
error:
mcs_write_command_and_free(mcs_err_packet(pkt, EBADFORMAT), wfd);
mcs_free(pkt);
error_no_notify:
return NULL;
}
BOOL rdp_client_redirect(rdpRdp* rdp)
{
rdpSettings* settings = rdp->settings;
rdpRedirection* redirection = rdp->redirection;
rdp_client_disconnect(rdp);
/* FIXME: this is a subset of rdp_free */
crypto_rc4_free(rdp->rc4_decrypt_key);
crypto_rc4_free(rdp->rc4_encrypt_key);
crypto_des3_free(rdp->fips_encrypt);
crypto_des3_free(rdp->fips_decrypt);
crypto_hmac_free(rdp->fips_hmac);
mcs_free(rdp->mcs);
nego_free(rdp->nego);
license_free(rdp->license);
transport_free(rdp->transport);
free(settings->ServerRandom);
free(settings->ServerCertificate);
free(settings->ClientAddress);
rdp->transport = transport_new(settings);
rdp->license = license_new(rdp);
rdp->nego = nego_new(rdp->transport);
rdp->mcs = mcs_new(rdp->transport);
rdp->transport->layer = TRANSPORT_LAYER_TCP;
settings->RedirectedSessionId = redirection->sessionID;
if (redirection->flags & LB_LOAD_BALANCE_INFO)
{
nego_set_routing_token(rdp->nego, redirection->LoadBalanceInfo, redirection->LoadBalanceInfoLength);
}
else
{
if (redirection->flags & LB_TARGET_NET_ADDRESS)
{
free(settings->ServerHostname);
settings->ServerHostname = _strdup(redirection->targetNetAddress.ascii);
}
else if (redirection->flags & LB_TARGET_FQDN)
{
free(settings->ServerHostname);
settings->ServerHostname = _strdup(redirection->targetFQDN.ascii);
}
else if (redirection->flags & LB_TARGET_NETBIOS_NAME)
{
free(settings->ServerHostname);
settings->ServerHostname = _strdup(redirection->targetNetBiosName.ascii);
}
}
if (redirection->flags & LB_USERNAME)
{
free(settings->Username);
settings->Username = _strdup(redirection->username.ascii);
}
if (redirection->flags & LB_DOMAIN)
{
free(settings->Domain);
settings->Domain = _strdup(redirection->domain.ascii);
}
if (redirection->flags & LB_PASSWORD)
{
settings->RedirectionPassword = redirection->PasswordCookie;
settings->RedirectionPasswordLength = redirection->PasswordCookieLength;
}
return rdp_client_connect(rdp);
}
tbool rdp_client_redirect(rdpRdp* rdp)
{
rdpSettings* settings = rdp->settings;
rdpRedirection* redirection = rdp->redirection;
rdp_client_disconnect(rdp);
mcs_free(rdp->mcs);
nego_free(rdp->nego);
license_free(rdp->license);
transport_free(rdp->transport);
rdp->transport = transport_new(settings);
rdp->license = license_new(rdp);
rdp->nego = nego_new(rdp->transport);
rdp->mcs = mcs_new(rdp->transport);
rdp->transport->layer = TRANSPORT_LAYER_TCP;
settings->redirected_session_id = redirection->sessionID;
if (redirection->flags & LB_LOAD_BALANCE_INFO)
{
nego_set_routing_token(rdp->nego, &redirection->loadBalanceInfo);
}
else
{
if (redirection->flags & LB_TARGET_NET_ADDRESS)
{
xfree(settings->hostname);
settings->hostname = xstrdup(redirection->targetNetAddress.ascii);
}
else if (redirection->flags & LB_TARGET_FQDN)
{
xfree(settings->hostname);
settings->hostname = xstrdup(redirection->targetFQDN.ascii);
}
else if (redirection->flags & LB_TARGET_NETBIOS_NAME)
{
xfree(settings->hostname);
settings->hostname = xstrdup(redirection->targetNetBiosName.ascii);
}
}
if (redirection->flags & LB_USERNAME)
{
xfree(settings->username);
settings->username = xstrdup(redirection->username.ascii);
}
if (redirection->flags & LB_DOMAIN)
{
xfree(settings->domain);
settings->domain = xstrdup(redirection->domain.ascii);
}
if (redirection->flags & LB_PASSWORD)
{
settings->password_cookie = &redirection->password_cookie;
}
return rdp_client_connect(rdp);
}
int mcs_write_command_and_free(MCSPacket *pkt, int fd)
{
int ret = mcs_write_command(pkt, fd);
mcs_free(pkt);
return ret;
}
mcs_st *lvb_create(mcs_st *ptr, const char *config) {
assert(ptr);
memset(ptr, 0, sizeof(*ptr));
ptr->kind = MCS_KIND_LIBVBUCKET;
VBUCKET_CONFIG_HANDLE vch = vbucket_config_parse_string(config);
if (vch != NULL) {
ptr->data = vch;
ptr->nservers = vbucket_config_get_num_servers(vch);
if (ptr->nservers > 0) {
ptr->servers = calloc(sizeof(mcs_server_st), ptr->nservers);
if (ptr->servers != NULL) {
for (int i = 0; i < ptr->nservers; i++) {
ptr->servers[i].fd = -1;
}
int j = 0;
for (; j < ptr->nservers; j++) {
const char *hostport = vbucket_config_get_server(vch, j);
if (hostport != NULL &&
strlen(hostport) > 0 &&
strlen(hostport) < sizeof(ptr->servers[j].hostname) - 1) {
strncpy(ptr->servers[j].hostname,
hostport,
sizeof(ptr->servers[j].hostname) - 1);
char *colon = strchr(ptr->servers[j].hostname, ':');
if (colon != NULL) {
*colon = '\0';
ptr->servers[j].port = atoi(colon + 1);
if (ptr->servers[j].port <= 0) {
moxi_log_write("mcs_create failed, could not parse port: %s\n",
config);
break;
}
} else {
moxi_log_write("mcs_create failed, missing port: %s\n",
config);
break;
}
} else {
moxi_log_write("mcs_create failed, unknown server: %s\n",
config);
break;
}
const char *user = vbucket_config_get_user(vch);
if (user != NULL) {
ptr->servers[j].usr = strdup(user);
}
const char *password = vbucket_config_get_password(vch);
if (password != NULL) {
ptr->servers[j].pwd = strdup(password);
}
}
if (j >= ptr->nservers) {
return ptr;
}
}
}
} else {
moxi_log_write("mcs_create failed, vbucket_config_parse_string: %s\n",
config);
}
mcs_free(ptr);
return NULL;
}
