int64_t ClusterMigrate::migrate_kv_data(Node *src_node, Node *dst_node, int num_keys){
src = init_client(src_node->ip, src_node->port);
if(src == NULL){
log_error("failed to connect to server!");
return -1;
}
dst = init_client(dst_node->ip, dst_node->port);
if(dst == NULL){
log_error("failed to connect to server!");
return -1;
}
if(check_version(src) == -1){
return -1;
}
if(check_version(dst) == -1){
return -1;
}
ssdb::Status s;
KeyRange src_range = src_node->range;
KeyRange dst_range = dst_node->range;
log_info("old src %s", src_range.str().c_str());
log_info("old dst %s", dst_range.str().c_str());
std::string moved_max_key;
int64_t bytes;
bytes = move_range(src_range.end, &moved_max_key, num_keys);
if(bytes == -1){
return -1;
}
if(bytes == 0){
return 0;
}
// update key range
src_node->range = KeyRange(moved_max_key, src_range.end);
{
dst_node->range = KeyRange(dst_range.begin, moved_max_key);
log_info("new dst: %s", dst_node->range.str().c_str());
ssdb::Status s = dst->set_kv_range(dst_node->range.begin, dst_node->range.end);
if(!s.ok()){
log_fatal("dst server set_kv_range error!");
return -1;
}
}
return bytes;
}
/**
* Create and init 2 master devices (VCP + VCK) and two slave devices, one
* default mouse, one default keyboard.
*/
struct devices init_devices(void)
{
ClientRec client;
struct devices devices;
client = init_client(0, NULL);
AllocDevicePair(&client, "Virtual core", &devices.vcp, &devices.vck,
CorePointerProc, CoreKeyboardProc, TRUE);
inputInfo.pointer = devices.vcp;
inputInfo.keyboard = devices.vck;
ActivateDevice(devices.vcp, FALSE);
ActivateDevice(devices.vck, FALSE);
EnableDevice(devices.vcp, FALSE);
EnableDevice(devices.vck, FALSE);
AllocDevicePair(&client, "", &devices.mouse, &devices.kbd,
CorePointerProc, CoreKeyboardProc, FALSE);
ActivateDevice(devices.mouse, FALSE);
ActivateDevice(devices.kbd, FALSE);
EnableDevice(devices.mouse, FALSE);
EnableDevice(devices.kbd, FALSE);
devices.num_devices = 4;
devices.num_master_devices = 2;
fake_init_sprite(devices.mouse);
fake_init_sprite(devices.vcp);
return devices;
}
MainDialogImpl::MainDialogImpl( QWidget * parent, Qt::WFlags f)
: QDialog(parent, f)
{
tray = new TrayMenu(this);
connect(tray,SIGNAL(exitClicked(bool)),
this,SLOT(exitClicked(bool)));
QSettings settings;
if(settings.value("first_launch",true).toBool())
{
SettingsDialog form;
form.setModal(true);
form.exec();
}
io = new RTorrentIO(0,
settings.value("host","localhost").toString(),
settings.value("port",80).toInt(),
settings.value("path","/RPC2").toString());
if(io)
{
connect(io,SIGNAL(started()),
this,SLOT(init_client()));
io->start();
}else
tray->disconnected();
}
int check_new_users(t_serv *serv, fd_set *rdfs, int nb_client)
{
t_user *tmp;
if (!FD_ISSET(serv->s, rdfs))
return (nb_client);
if (serv->chan[0].users == NULL)
{
serv->chan[0].users = xmalloc(sizeof(*tmp));
tmp = serv->chan[0].users;
}
else
{
tmp = serv->chan[0].users;
for (tmp = tmp; tmp->n != NULL; tmp = tmp->n);
tmp->n = xmalloc(sizeof(*tmp));
tmp = tmp->n;
}
tmp->cs = accept(serv->s, (struct sockaddr *)serv->csin, (socklen_t *)&serv->csize);
if (tmp->cs == -1)
{
xclose(serv->s);
handle_error("accept");
}
printf("new\n");
init_client(serv, tmp, nb_client);
return (nb_client + 1);
}
int new_client(t_server *server, int *actual, char *buff)
{
int csock;
t_sockaddr_in csin;
socklen_t sinsize;
sinsize = sizeof(csin);
csock = accept(server->sock, (t_sockaddr *)&csin, &sinsize);
if (csock == SOCKET_ERROR)
{
error("accept");
return (-1);
}
if (read_client(csock, buff) == -1)
return (-1);
while (check_pseudo(buff, server) == -1)
{
write_client(csock, "Pseudo already used");
if (read_client(csock, buff) == -1)
return (-1);
}
FD_SET(csock, &(server->rdfs));
server->max = csock > server->max ? csock : server->max;
init_client(server, *actual, buff, csock);
(*actual)++;
return (csock);
}
int main(int argc, char **argv) {
/* number of bytes read */
int numbytes = 0;
/* check command line arguments */
if (argc != 3) {
fprintf(stderr,"usage: %s <hostname> <port>\n", argv[0]);
exit(EXIT_SUCCESS);
}
/* initialize client connection */
if(init_client(argv[1], atoi(argv[2]))!=0){
printf("Exiting.\n");
goto out;
}
/* print the server stream */
while(1){
/* clean the buffer */
bzero(buf, BUFSIZE);
/* read from socket */
if((numbytes = read(sockfd, buf, BUFSIZE))<0){
printf("ERROR reading from socket\n");
goto out;
}
/* for proper printing*/
buf[BUFSIZE]='\0';
printf("%s", buf);
}
out:
close(sockfd);
return (EXIT_SUCCESS);
}
/* 1 - 7 is the range we use for the global modifiers array
* above */
assert(mods->modifiers > 0);
assert(mods->modifiers <= 7);
assert(mods->modifiers % 2 == 1); /* because we fail odd ones */
assert(mods->status != Success);
assert(mods->pad0 == 0);
assert(mods->pad1 == 0);
}
reply_handler = reply_XIPassiveGrabDevice;
}
static void request_XIPassiveGrabDevice(ClientPtr client, xXIPassiveGrabDeviceReq* req, int error, int errval)
{
int rc;
int modifiers;
rc = ProcXIPassiveGrabDevice(&client_request);
assert(rc == error);
if (rc != Success)
assert(client_request.errorValue == errval);
client_request.swapped = TRUE;
swaps(&req->length);
swapl(&req->time);
swapl(&req->grab_window);
swapl(&req->cursor);
swapl(&req->detail);
swaps(&req->deviceid);
modifiers = req->num_modifiers;
swaps(&req->num_modifiers);
swaps(&req->mask_len);
while(modifiers--)
{
CARD32 *mod = ((CARD32*)(req + 1)) + modifiers;
swapl(mod);
}
rc = SProcXIPassiveGrabDevice(&client_request);
assert(rc == error);
if (rc != Success)
assert(client_request.errorValue == errval);
}
static unsigned char *data[4096]; /* the request buffer */
static void test_XIPassiveGrabDevice(void)
{
int i;
xXIPassiveGrabDeviceReq *request = (xXIPassiveGrabDeviceReq*)data;
unsigned char *mask;
request_init(request, XIPassiveGrabDevice);
request->grab_window = CLIENT_WINDOW_ID;
reply_handler = reply_XIPassiveGrabDevice;
client_request = init_client(request->length, request);
printf("Testing invalid device\n");
request->deviceid = 12;
request_XIPassiveGrabDevice(&client_request, request, BadDevice, request->deviceid);
request->deviceid = XIAllMasterDevices;
printf("Testing invalid grab types\n");
for (i = XIGrabtypeFocusIn + 1; i < 0xFF; i++)
{
request->grab_type = i;
request_XIPassiveGrabDevice(&client_request, request, BadValue, request->grab_type);
}
printf("Testing invalid grab type + detail combinations\n");
request->grab_type = XIGrabtypeEnter;
request->detail = 1;
request_XIPassiveGrabDevice(&client_request, request, BadValue, request->detail);
request->grab_type = XIGrabtypeFocusIn;
request_XIPassiveGrabDevice(&client_request, request, BadValue, request->detail);
request->detail = 0;
printf("Testing invalid masks\n");
mask = (unsigned char*)&request[1];
request->mask_len = bytes_to_int32(XI2LASTEVENT + 1);
request->length += request->mask_len;
SetBit(mask, XI2LASTEVENT + 1);
request_XIPassiveGrabDevice(&client_request, request, BadValue, XI2LASTEVENT + 1);
ClearBit(mask, XI2LASTEVENT + 1);
/* tested all special cases now, test a few valid cases */
/* no modifiers */
request->deviceid = XIAllDevices;
request->grab_type = XIGrabtypeButton;
request->detail = XIAnyButton;
request_XIPassiveGrabDevice(&client_request, request, Success, 0);
/* some modifiers */
request->num_modifiers = N_MODS;
request->length += N_MODS;
memcpy((uint32_t*)(request + 1) + request->mask_len, modifiers, sizeof(modifiers));
request_XIPassiveGrabDevice(&client_request, request, Success, 0);
}
int main(int argc , char *argv[])
{
Client* client = mymalloc(sizeof(Client));
init_client(client);
client->fdmax=STDIN_FILENO;
FD_SET(STDIN_FILENO, &(client->fd_read_set));
while(TRUE) {
client->fd_read_set_select = client->fd_read_set;
client->fd_write_set_select = client->fd_write_set;
select(client->fdmax+1, &(client->fd_read_set_select),
&(client->fd_write_set_select),
NULL, NULL);
if (FD_ISSET(STDIN_FILENO, &(client->fd_read_set_select)))
handle_std_input(client);
else if(FD_ISSET(client->listening_fd, &(client->fd_read_set_select)))
handle_new_client(client);
else if(FD_ISSET(client->maintainer_fd, &(client->fd_read_set_select)))
read_server_msg(client);
else if(FD_ISSET(client->maintainer_fd, &(client->fd_write_set_select)))
write_server_msg(client);
else
for(int i=1; i<=client->fdmax; ++i)
if(FD_ISSET(i, &(client->fd_read_set_select)))
read_client_msg(client, i);
else if(FD_ISSET(i, &(client->fd_write_set_select)))
write_client_msg(client, i);
}
myfree(client);
return 0;
}
//
// argv[1] should contain one of the role: server or client.
//
int main(int argc, const char * argv[]) {
role_t role = RoleUnknown;
if (argc>1) {
if ( strcmp(argv[1], SERVER_ROLE_ARG)==0 ) {
role = RoleServer;
}
else if ( strcmp(argv[1], CLIENT_ROLE_ARG)==0 ) {
role = RoleClient;
}
else {
printf("Unknown role. The role must be either 'server' or 'client'\n");
return EXIT_FAILURE;
}
}
else {
printf("You have to specify a role (server or client)\n");
return EXIT_FAILURE;
}
if (role == RoleClient) {
printf("Start client\n");
init_client();
}
else if (role == RoleServer) {
printf("Start server\n");
init_server();
}
return EXIT_SUCCESS;
}
int main(int argc, char *argv[]){
/* Initialise a client on the port 8888 and the localhost ip*/
int sock = init_client(8888, inet_addr("127.0.0.1"));
/* Check if the init succes */
if (sock < 0){
//Error
return -1;
}
/* Print something */
printf("Connection succes, write what you want to send and press ENTER\n");
/* Send what you write and get the answer */
char msg[1000];
while(scanf("%s", msg)){
char *answer = send_and_get_answer(sock, msg);
if (answer != NULL){
printf("%s\n", answer);
}
}
/* Close the socket */
close_socket(&sock);
return 0;
}
int runpartialgetresponsetest(char *hostname, char *username, char *password)
{
int session_id = -1;
int i = 0;
int total= 100;
int batchsize = 10;
char *batchid = "batchid";
char *request[total];
char *userdata[total];
for(; i < total; i++)
{
request[i] = malloc(1024);
sprintf(request[i], "req%d", i);
userdata[i] = malloc(1024);
sprintf(userdata[i], "userdata%d", i);
}
init_client(hostname, username, password);
session_id = create_session();
send_request(session_id, batchid, request, userdata, total, true);
get_response(session_id, batchid, "", "", batchsize, true);
i = 1;
for(; i < 9; i++)
{
get_response(session_id, batchid, "", "", batchsize, false);
}
close_session(session_id);
return 0;
}
int main(int argc, char * argv[]) {
init_client();
start_transaction();
close_client();
fprintf(stderr, "closed.....\n");
return 0;
}
int main(int ac, char **av)
{
if (ac < 3)
ft_exit("\033[1;33mUsage : ./client <ip> <port> [nickname]\033[0m\n");
init_client(ac, av);
return (0);
}
int arm_open(int *socket, struct sockaddr_in *address, char *ip_address, int dest_port)
{
// Init circular buffer
arm_buffer_tx_ptr_wr = 0;
arm_buffer_tx_ptr_rd = 0;
arm_buffer_tx_empty = 1;
arm_buffer_tx_full = 0;
arm_buffer_tx_overrun = 0;
arm_buffer_tx_data_count = 0;
arm_buffer_rx_ptr_wr = 0;
arm_buffer_rx_ptr_rd = 0;
arm_buffer_rx_empty = 1;
arm_buffer_rx_full = 0;
arm_buffer_rx_overrun = 0;
arm_buffer_rx_data_count = 0;
if(init_client(socket, address, ip_address, dest_port) == -1)
return 0;
else
{
arm_net_down = 0;
return 1;
}
}
static void request_XIQueryDevice(struct test_data *querydata,
int deviceid, int error)
{
int rc;
ClientRec client;
xXIQueryDeviceReq request;
request_init(&request, XIQueryDevice);
client = init_client(request.length, &request);
reply_handler = reply_XIQueryDevice;
querydata->which_device = deviceid;
request.deviceid = deviceid;
rc = ProcXIQueryDevice(&client);
assert(rc == error);
if (rc != Success)
assert(client.errorValue == deviceid);
reply_handler = reply_XIQueryDevice;
client.swapped = TRUE;
swaps(&request.length);
swaps(&request.deviceid);
rc = SProcXIQueryDevice(&client);
assert(rc == error);
if (rc != Success)
assert(client.errorValue == deviceid);
}
int main(int argc, char *argv[])//bank_id client_id
{
if (argc != 3)
{
printf("input error\n");
exit(1);
}
memset(recv_table, false, 200 * sizeof(bool));
last_rec_id = 0;
/*init client and get client's information from the config file */
init_client(atoi(argv[1]), atoi(argv[2]));
string q1 = argv[1], q2 = argv[2];
string my_log_file = "../../logs/bank" + q1 + "/client-" + q2 + ".txt";
out = fopen(my_log_file.c_str(), "w+" );
pthread_create(&rec_thread, NULL, recv_msg, NULL);
sleep(1);//wait for master reply
send_request();
pthread_join(rec_thread, NULL);
fclose(out);
return 0;
}/*main*/
int main(int argc, char *argv[])
{
int opt;
struct option longopts[] = {
{"initialize", 0, NULL, 'i'},
{"help", 0, NULL, 'h'},
{"list", 0, NULL, 'l'},
{"restart", 0, NULL, 'r'},
{0,0,0,0}
};
#if 0
while((opt = getopt(argc, argv, ":if:lr:h")) != -1) {
switch(opt) {
case 'i':
case 'h':
case 'r':
printf("option: %c\n", opt);
break;
case 'f':
printf("filename: %s\n", optarg);
break;
case ':':
printf("option needs a value\n");
break;
case '?':
printf("unknown option: %c\n", optopt);
break;
}
}
for(; optind < argc; optind++)
printf("argument: %s\n", argv[optind]);
#endif
do {
get_help();
switch(opt)
{
case 1:
init_server();
break;
case 2:
init_sla_support();
break;
case 3:
init_client();
break;
default:
printf("Oops you might pressed '%d' ", opt );
}
} while(opt != 0);
while(1)
{
sleep(1000);
}
}
static int
speedtest(int dl_enable, int ul_enable)
{
int i;
client_config_t client;
server_config_t servers[CLOSEST_SERVERS_NUM];
server_config_t best_server;
for (i = 0; i < CLOSEST_SERVERS_NUM; i++) {
init_server(&servers[i]);
}
init_server(&best_server);
init_client(&client);
if (get_speedtest_config(&client)) {
fprintf(stderr, "get_speedtest_config error!\n");
nvram_set("speedtest_running", "2");
return -1;
}
if (get_nearest_servers(&client, servers)) {
fprintf(stderr, "get_nearest_servers error!\n");
nvram_set("speedtest_running", "2");
return -1;
}
client_free(&client);
if (get_lowest_latency_server(servers, &best_server)) {
fprintf(stderr, "get_lowest_latency_server error!\n");
nvram_set("speedtest_running", "2");
return -1;
}
if (dl_enable == 1) {
if (test_download_speed(&best_server)) {
fprintf(stderr, "test_download_speed error!\n");
nvram_set("speedtest_running", "2");
return -1;
}
}
if (ul_enable == 1) {
finished = (double)0;
if (test_upload_speed(&best_server)) {
fprintf(stderr, "test_upload_speed error!\n");
nvram_set("speedtest_running", "2");
return -1;
}
}
for (i = 0; i < CLOSEST_SERVERS_NUM; i++) {
server_free(&servers[i]);
}
nvram_set("speedtest_running", "1");
nvram_commit();
return 0;
}
void server()
{
int sock_fd = -1;
struct sockaddr_in my_addr;
int addr_len = 0;
int c_nums = 0;
int opt = 1;
int len = sizeof(opt);
pthread_t thread_id;
init_client(client);
my_addr.sin_family = AF_INET;
my_addr.sin_port = htons(SERVPORT);
my_addr.sin_addr.s_addr = INADDR_ANY;
bzero(&(my_addr.sin_zero), 8);
addr_len = sizeof(struct sockaddr_in);
if((sock_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
perror("socket");
exit(1);
}
setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &opt, len);
if(bind(sock_fd, (struct sockaddr*)&my_addr, sizeof(my_addr)) == -1)
{
perror("bind");
exit(1);
}
if(listen(sock_fd, BACKLOG) == -1)
{
perror("listen");
exit(1);
}
while(1)
{
if((client[c_nums].fd = accept(sock_fd,
(struct sockaddr*)&client[c_nums].addr,
&addr_len)) == -1)
{
perror("accept");
continue;
}
#ifdef DEBUG_VERSION
printf("received a connection from %s\nfd:%d\nc_nums:%d\n",
inet_ntoa(client[c_nums].addr.sin_addr),
client[c_nums].fd, c_nums);
#endif
pthread_create(&thread_id, NULL, &msg_processor, (void*)&client[c_nums]);
c_nums = (c_nums+1)%MAXPEOPLE;
}
close(sock_fd);
}
int main(int argc, char* argv[]) {
if(argc != 4)
error("usage: host port [tcp, udp]");
char* host = argv[1];
int port = atoi(argv[2]);
char* proto = argv[3];
int sock_fd = init_client(host, port, proto);
test_request(sock_fd, proto);
}
int
main(int argc, char **argv)
{
init_simple();
client_window = init_client(0, NULL);
test_XIGetClientPointer();
return 0;
}
void delete_client(t_server *serv, int fd)
{
close(fd);
free(serv->client[fd].realname);
free(serv->client[fd].username);
freelist(serv->client[fd].channel);
printf("Client deleted: %s, socket %d closed\n", serv->client[fd].nick, fd);
init_client(serv, fd);
serv->fd_type[fd] = FD_FREE;
}
int
protocol_xisetclientpointer_test(void)
{
init_simple();
client_window = init_client(0, NULL);
test_XISetClientPointer();
return 0;
}
static void
on_context_available (GUPnPContextManager *manager,
GUPnPContext *context,
gpointer user_data)
{
/* Initialize client-side stuff */
init_client (context);
/* Then the server-side stuff */
init_server (context);
}
static void test_XIQueryPointer(void)
{
int i;
xXIQueryPointerReq request;
memset(&request, 0, sizeof(request));
request_init(&request, XIQueryPointer);
reply_handler = reply_XIQueryPointer;
client_request = init_client(request.length, &request);
request.deviceid = XIAllDevices;
request_XIQueryPointer(&client_request, &request, BadDevice);
request.deviceid = XIAllMasterDevices;
request_XIQueryPointer(&client_request, &request, BadDevice);
request.win = root.drawable.id;
test_data.win = &root;
test_data.dev = devices.vcp;
request.deviceid = devices.vcp->id;
request_XIQueryPointer(&client_request, &request, Success);
request.deviceid = devices.vck->id;
request_XIQueryPointer(&client_request, &request, BadDevice);
request.deviceid = devices.mouse->id;
request_XIQueryPointer(&client_request, &request, BadDevice);
request.deviceid = devices.kbd->id;
request_XIQueryPointer(&client_request, &request, BadDevice);
test_data.dev = devices.mouse;
devices.mouse->u.master = NULL; /* Float, kind-of */
request.deviceid = devices.mouse->id;
request_XIQueryPointer(&client_request, &request, Success);
for (i = devices.kbd->id + 1; i <= 0xFFFF; i++)
{
request.deviceid = i;
request_XIQueryPointer(&client_request, &request, BadDevice);
}
request.win = window.drawable.id;
test_data.dev = devices.vcp;
test_data.win = &window;
request.deviceid = devices.vcp->id;
request_XIQueryPointer(&client_request, &request, Success);
test_data.dev = devices.mouse;
request.deviceid = devices.mouse->id;
request_XIQueryPointer(&client_request, &request, Success);
}
void init_rfs_instance(struct rfs_instance *instance)
{
init_client(instance);
init_attr_cache(&instance->attr_cache);
init_id_lookup(&instance->id_lookup);
init_resume(instance);
init_write_cache(instance);
init_sendrecv(&instance->sendrecv);
init_nss(instance);
init_rfs_config(instance);
}
/**
* Create and init 2 master devices (VCP + VCK) and two slave devices, one
* default mouse, one default keyboard.
*/
struct devices
init_devices(void)
{
ClientRec client;
struct devices local_devices;
int ret;
/*
* Put a unique name in display pointer so that when tests are run in
* parallel, their xkbcomp outputs to /tmp/server-<display>.xkm don't
* stomp on each other.
*/
#ifdef HAVE_GETPROGNAME
display = getprogname();
#elif HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME
display = program_invocation_short_name;
#endif
client = init_client(0, NULL);
AllocDevicePair(&client, "Virtual core", &local_devices.vcp, &local_devices.vck,
CorePointerProc, CoreKeyboardProc, TRUE);
inputInfo.pointer = local_devices.vcp;
inputInfo.keyboard = local_devices.vck;
ret = ActivateDevice(local_devices.vcp, FALSE);
assert(ret == Success);
/* This may fail if xkbcomp fails or xkb-config is not found. */
ret = ActivateDevice(local_devices.vck, FALSE);
assert(ret == Success);
EnableDevice(local_devices.vcp, FALSE);
EnableDevice(local_devices.vck, FALSE);
AllocDevicePair(&client, "", &local_devices.mouse, &local_devices.kbd,
TestPointerProc, CoreKeyboardProc, FALSE);
ret = ActivateDevice(local_devices.mouse, FALSE);
assert(ret == Success);
ret = ActivateDevice(local_devices.kbd, FALSE);
assert(ret == Success);
EnableDevice(local_devices.mouse, FALSE);
EnableDevice(local_devices.kbd, FALSE);
local_devices.num_devices = 4;
local_devices.num_master_devices = 2;
fake_init_sprite(local_devices.mouse);
fake_init_sprite(local_devices.vcp);
return local_devices;
}
int runattachsessiontest(char *hostname, char *username, char *password)
{
int session_id = -1;
init_client(hostname, username, password);
session_id = create_session();
if(session_id < 0)
{
fprintf(stderr, "create_session() failed\n");
return -1;
}
attach_session(session_id);
close_session(session_id);
printf("AttachSessionTest passed\n");
return 0;
}
static void
test_XIGetClientPointer(void)
{
xXIGetClientPointerReq request;
request_init(&request, XIGetClientPointer);
request.win = CLIENT_WINDOW_ID;
reply_handler = reply_XIGetClientPointer;
client_request = init_client(request.length, &request);
printf("Testing invalid window\n");
request.win = INVALID_WINDOW_ID;
request_XIGetClientPointer(&client_request, &request, BadWindow);
printf("Testing invalid length\n");
client_request.req_len -= 4;
request_XIGetClientPointer(&client_request, &request, BadLength);
client_request.req_len += 4;
test_data.cp_is_set = FALSE;
printf("Testing window None, unset ClientPointer.\n");
request.win = None;
request_XIGetClientPointer(&client_request, &request, Success);
printf("Testing valid window, unset ClientPointer.\n");
request.win = CLIENT_WINDOW_ID;
request_XIGetClientPointer(&client_request, &request, Success);
printf("Testing valid window, set ClientPointer.\n");
client_window.clientPtr = devices.vcp;
test_data.dev = devices.vcp;
test_data.cp_is_set = TRUE;
request.win = CLIENT_WINDOW_ID;
request_XIGetClientPointer(&client_request, &request, Success);
client_window.clientPtr = NULL;
printf("Testing window None, set ClientPointer.\n");
client_request.clientPtr = devices.vcp;
test_data.dev = devices.vcp;
test_data.cp_is_set = TRUE;
request.win = None;
request_XIGetClientPointer(&client_request, &request, Success);
}
int main(int argc, char *argv[])
{
set_folders();
initialize();
set_signals();
//Iniciar el cliente como servidor de ficheros
if (init_client() == -1)
error("Error on init client");
while(1)
{
userin();
procline();
}
}