void TEST_cleanup() {
char *routine = "TEST_cleanup";
printf(testing, routine);
assert(_check_init()); //In case this hasn't been called
assert(defaults);
cleanup();
assert(defaults == NULL);
assert(_check_init()); //So that I don't have to call this elsewhere
printf(done, routine);
}
long desktop_count() {
if (!_check_init()) {
return -1;
}
if (!_is_supported_feature("_NET_NUMBER_OF_DESKTOPS")) {
fprintf(stderr,
"Your window manager does not support _NET_NUMBER_OF_DESKTOPS "
"so I'm returning 1 since you obviously have one desktop");
return 1;
}
Atom type;
int size = 0;
long item_count = 0;
long ret = 1;
Window root = XDefaultRootWindow(defaults->display);
Atom request =
XInternAtom(defaults->display, "_NET_NUMBER_OF_DESKTOPS", FALSE);
unsigned char *data =
_window_property(root, request, &item_count, &type, &size);
if (item_count > 0) {
ret = *((long*) data);
}
if(data) {
XFree(data);
}
return ret;
}
void ds_msg_print_header(ds_msg_handle_t *handle,
FILE *out, char *spacer)
{
_check_init(handle);
fprintf(out, "%sDsMessage:\n", spacer);
fprintf(out, "%s type: %d\n", spacer, handle->hdr.type);
fprintf(out, "%s subType: %d\n", spacer, handle->hdr.subType);
fprintf(out, "%s mode: %d\n", spacer, handle->hdr.mode);
fprintf(out, "%s flags: %d\n", spacer, handle->hdr.flags);
fprintf(out, "%s majorVersion: %d\n", spacer, handle->hdr.majorVersion);
fprintf(out, "%s minorVersion: %d\n", spacer, handle->hdr.minorVersion);
fprintf(out, "%s serialNum: %d\n", spacer, handle->hdr.serialNum);
fprintf(out, "%s nParts: %d\n", spacer, handle->hdr.nParts);
if (handle->hdr.category == DS_MSG_GENERIC) {
fprintf(out, "%s category: Generic\n", spacer);
} else if (handle->hdr.category == DS_MSG_SERVER_STATUS) {
fprintf(out, "%s category: ServerStatus\n", spacer);
} else {
fprintf(out, "%s category: Unknown\n", spacer);
}
}
BOOL mouse_click(unsigned short btn, unsigned short count) {
if(btn < 1) {
fprintf(stderr,
"The first mouse button is #1, clicking '0' will not work\n");
return FALSE;
}
if (!_check_init()) {
return FALSE;
}
BOOL success = TRUE;
unsigned short i;
for (i = 0; i < count; i++) {
success = mouse_down(btn);
logit(LOG_LEVEL_VERBOSE, "Mouse button %d down ", btn);
if (!success) {
mouse_up(btn); //Just in case
break;
}
usleep(MILLI_MULTIPLIER * defaults->mouse_down_delay);
success = mouse_up(btn);
logit(LOG_LEVEL_VERBOSE, "Mouse button %d up\n", btn);
if (i < count - 1) {
usleep(MILLI_MULTIPLIER * defaults->mouse_click_delay);
}
}
return (success != 0);
}
BOOL _normalize_wincoords(int *x, int *y, unsigned long win) {
if (!_check_init()) {
return FALSE;
}
XWindowAttributes *attribs = calloc(1, sizeof(XWindowAttributes));
if(attribs == NULL) {
fprintf(stderr, "Unable to allocate space for XWindowAttributes");
return FALSE;
}
XSetErrorHandler(_invalid_window_error_handler);
int status = XGetWindowAttributes(defaults->display, win, attribs);
XSetErrorHandler(NULL);
BOOL ret;
if (status) {
int winx = window_x(win);
int winy = window_y(win);
*x = winx + *x;
*y = winy + *y;
logit(LOG_LEVEL_VERBOSE, "Window at %d X %d\n", winx, winy);
logit(LOG_LEVEL_VERBOSE, "Relative location %d X %d\n", *x, *y);
ret = TRUE;
} else {
fprintf(stderr, "Window handle %lu appears to be invalid\n", win);
fprintf(stderr, "Not moving the mouse\n");
*x = mouse_x(0);
*y = mouse_y(0);
ret = FALSE;
}
free(attribs);
//In case the window is partially off the screen
_normalize_coords(x, y);
return ret;
}
void ds_msg_free_handle(ds_msg_handle_t *handle)
{
_check_init(handle);
if (handle->parts) {
int i;
for (i = 0; i < handle->hdr.nParts; i++) {
if (handle->parts[i].buf) {
ufree(handle->parts[i].buf);
handle->parts[i].buf = NULL;
handle->parts[i].n_buf_alloc = 0;
}
}
ufree(handle->parts);
handle->parts = NULL;
handle->n_parts_alloc = 0;
}
if (handle->assembled_msg) {
ufree (handle->assembled_msg);
handle->assembled_msg = NULL;
handle->n_assembled_alloc = 0;
}
handle->init_flag = 0;
}
long desktop(long desk) {
if (!_check_init()) {
return -1;
}
if(desk > -1) {
set_current_desktop(desk);
}
return get_current_desktop();
}
BOOL mouse_up(unsigned short btn) {
if (!_check_init()) {
return FALSE;
}
BOOL success = XTestFakeButtonEvent(defaults->display, btn, FALSE,
CurrentTime );
XFlush(defaults->display);
return (success != 0);
}
void verbose(BOOL verbose) {
if (_check_init()) {
if(verbose) {
defaults->log_level |= LOG_LEVEL_VERBOSE;
} else {
defaults->log_level &= (! LOG_LEVEL_VERBOSE);
}
}
}
void extra_verbose(BOOL extra_verbose) {
if (_check_init()) {
if(extra_verbose) {
defaults->log_level |= LOG_LEVEL_EXTRA_VERBOSE;
} else {
defaults->log_level &= (! LOG_LEVEL_EXTRA_VERBOSE);
}
}
}
ds_msg_part_t *ds_msg_get_part(ds_msg_handle_t *handle,
int index)
{
_check_init(handle);
if (index > handle->hdr.nParts - 1) {
return (NULL);
}
return (handle->parts + index);
}
void ds_msg_add_part(ds_msg_handle_t *handle,
int type, int len, void *data)
{
_check_init(handle);
_alloc_parts(handle, handle->hdr.nParts + 1);
ds_msg_load_part_from_mem(handle->parts + handle->hdr.nParts,
type, len, data);
handle->hdr.nParts++;
}
PRFileDesc* PR_OpenUDPTransportSocket(PRIntn af, const char* host,
PRInt32 port) {
_check_init();
PRFileDesc* socks[2] = {0};
UDTSOCKET udt_socket = UDT::INVALID_SOCK;
PRUdtSocketDesc* p_desc = NULL;
if (UDT::INVALID_SOCK == (udt_socket = UDT::socket(af, SOCK_STREAM, 0)))
goto cleanup;
if (PR_SUCCESS != PR_NewTCPSocketPair(socks))
goto cleanup;
PRFileDesc* udpt_fd = PR_CreateIOLayerStub(_udpt_desc_identity,
&udptMethods);
p_desc = (PRUdtSocketDesc*)PR_Malloc(sizeof(PRUdtSocketDesc));
if (UDT::bind_events(udt_socket, UDT_EPOLL_IN, _udp_event_cb, p_desc) < 0)
goto cleanup;
if ((NULL != udpt_fd) && (NULL != p_desc)) {
PRFileDesc * sockpair_fd = socks[0];
memset(p_desc, 0, sizeof(PRUdtSocketDesc));
p_desc->sock_pair0 = socks[0];
p_desc->sock_pair1 = socks[1];
p_desc->dtor = udpt_fd->dtor;
p_desc->udtfd = udt_socket;
udpt_fd->secret = (PRFilePrivate*)p_desc;
udpt_fd->lower = sockpair_fd;
sockpair_fd->higher = udpt_fd;
udpt_fd->dtor = _udtp_detor;
return udpt_fd;
}
cleanup:
if (NULL != socks[0])
PR_Close(socks[0]);
if (NULL != socks[1])
PR_Close(socks[1]);
if (UDT::INVALID_SOCK == udt_socket)
UDT::close(udt_socket);
if (NULL != p_desc)
PR_Free(p_desc);
if (NULL != udpt_fd)
PR_Close(udpt_fd);
return NULL;
}
void _normalize_coords(int *x, int *y) {
if (!_check_init()) {
return;
}
if (*x < 0) {
*x = 0;
} else if (*x > defaults->dsp_width) {
x = &defaults->dsp_width;
}
if (*y < 0) {
*y = 0;
} else if (*y > defaults->dsp_height) {
y = &defaults->dsp_height;
}
logit(LOG_LEVEL_VERBOSE, "Final mouse location %d X %d\n", *x, *y);
}
int ds_msg_part_exists(ds_msg_handle_t *handle,
int data_type)
{
int count = 0;
int i;
_check_init(handle);
for (i = 0; i < handle->hdr.nParts; i++) {
if (handle->parts[i].type == data_type) {
count++;
}
}
return (count);
}
BOOL move_mouse(int newX, int newY, Window win) {
int loop = 0;
if (!_check_init()) {
return FALSE;
}
BOOL success = TRUE;
logit(LOG_LEVEL_VERBOSE, "Window handle: %lu\n", win);
if (win) {
success = _normalize_wincoords(&newX, &newY, win);
if(success == FALSE) {
return FALSE;
}
} else {
_normalize_coords(&newX, &newY);
}
if (defaults->mouse_move_delay == ZERO) {
return _do_movement(newX, newY);
} else {
int oldX = mouse_x(0L);
int oldY = mouse_y(0L);
while (oldX != newX || oldY != newY) {
int movementX, movementY;
_gradientMovement(newX, newY, &movementX, &movementY);
// 1:1 is a little slow
if ((fabs(movementX) == 1 && fabs(movementY) == 1) &&
(fabs(newX - oldX) > 1 && fabs(newY - oldY) > 1) ) {
movementX *= 2;
movementY *= 2;
}
oldX += movementX;
oldY += movementY;
success &= _do_movement(oldX, oldY);
if (!success) {
fprintf(stderr, "Simulation of mouse movement failed.\n");
break;
}
usleep(50 * defaults->mouse_move_delay);
loop++;
if (loop > 10000) {
return FALSE;
} //Probably something is wrong
}
}
return success;
}
PRFileDesc* PR_OpenUDPTransportSocket(PRIntn af, const char* host,
PRInt32 port) {
_check_init();
PRFileDesc* socks[2] = {0};
UDTSOCKET u_socket = UDT_UDT_SNDBUF;
PRUdtSocketDesc* p_desc = NULL;
u_socket = udt_socket(af, SOCK_STREAM, 0);
PRStatus status_pr = PR_NewTCPSocketPair(socks);
PRFileDesc* udpt_fd = PR_CreateIOLayerStub(_udpt_desc_identity,
&udptMethods);
p_desc = (PRUdtSocketDesc*)PR_Malloc(sizeof(PRUdtSocketDesc));
int status_udt = udt_bind_events(u_socket, UDT_UDT_EPOLL_IN, (void*)_udp_event_cb, p_desc);
if ((NULL != udpt_fd) && (NULL != p_desc) && (status_udt >= 0)
&& (status_pr == PR_SUCCESS))
{
PRFileDesc * sockpair_fd = socks[0];
memset(p_desc, 0, sizeof(PRUdtSocketDesc));
p_desc->sock_pair0 = socks[0];
p_desc->sock_pair1 = socks[1];
p_desc->dtor = udpt_fd->dtor;
p_desc->udtfd = u_socket;
udpt_fd->secret = (PRFilePrivate*)p_desc;
udpt_fd->lower = sockpair_fd;
sockpair_fd->higher = udpt_fd;
udpt_fd->dtor = _udtp_detor;
return udpt_fd;
}
if (NULL != socks[0])
PR_Close(socks[0]);
if (NULL != socks[1])
PR_Close(socks[1]);
if (UDT_INVALID_SOCK != u_socket)
udt_close(u_socket);
if (NULL != p_desc)
PR_Free(p_desc);
if (NULL != udpt_fd)
PR_Close(udpt_fd);
return NULL;
}
BOOL set_current_desktop(long desktop) {
if (!_check_init()) {
return FALSE;
}
if (!_is_supported_feature("_NET_WM_DESKTOP")) {
fprintf(stderr,
"Apparently your window manager doesn't support "
"_NET_WM_DESKTOP so I'm leaving you where you are.\n");
return FALSE;
}
logit(LOG_LEVEL_VERBOSE, "Switching to desktop %ld\n", desktop);
desktop--; //Force desktop to be one based rather than zero based
if(desktop < 0) {
char *msg = "This software starts desktop indexes at 1, so your"
" request for desktop %ld failed\n";
fprintf(stderr, msg, (desktop +1));
return FALSE;
}
if((desktop +1) > desktop_count()) {
char *msg = "You have specified desktop %ld, but you have only %ld"
" desktops available\n";
fprintf(stderr, msg, (desktop +1), desktop_count());
return FALSE;
}
Window root = RootWindow(defaults->display, 0);
XEvent event;
memset(&event, 0, sizeof(event));
event.xclient.format = 32;
event.xclient.data.l[0] = desktop;
event.xclient.data.l[1] = CurrentTime;
event.type = ClientMessage;
event.xclient.display = defaults->display;
event.xclient.window = root;
event.xclient.message_type =
XInternAtom(defaults->display, "_NET_CURRENT_DESKTOP", FALSE);
long mask = SubstructureNotifyMask | SubstructureRedirectMask;
Status status =
XSendEvent(defaults->display, root, FALSE, mask, &event );
XFlush(defaults->display);
return (status != 0);
}
short mouse_down_delay(short delay) {
if(!_check_init()) {
return -1;
}
if(delay < 1) {
return defaults->mouse_down_delay;
}
{
char *msg = "The mouse button used to stay down for %hu"
" milliseconds when clicked\n";
logit(LOG_LEVEL_EXTRA_VERBOSE, msg, defaults->mouse_down_delay);
}
defaults->mouse_down_delay = delay;
{
char *msg = "The mouse button now stays down for %hu"
" milliseconds when clicked\n";
logit(LOG_LEVEL_EXTRA_VERBOSE, msg, defaults->mouse_down_delay);
}
return defaults->mouse_down_delay;
}
short mouse_click_delay(short delay) {
if(!_check_init()) {
return -1;
}
if(delay < 1) {
return defaults->mouse_click_delay;
}
{
char *msg = "The mouse button used to pause for %hu"
" milliseconds between clicks\n";
logit(LOG_LEVEL_EXTRA_VERBOSE, msg, defaults->mouse_down_delay);
}
defaults->mouse_click_delay = delay;
{
char *msg = "The mouse button now pauses for %hu"
" milliseconds between clicks\n";
logit(LOG_LEVEL_EXTRA_VERBOSE, msg, defaults->mouse_down_delay);
}
return defaults->mouse_click_delay;
}
int ds_msg_disassemble(ds_msg_handle_t *handle,
void *in_msg, int msg_len)
{
int i;
_check_init(handle);
ds_msg_decode_header(handle, in_msg);
_alloc_parts(handle, handle->hdr.nParts);
for (i = 0; i < handle->hdr.nParts; i++) {
if (ds_msg_load_part_from_msg(handle->parts + i,
i, in_msg, msg_len)) {
ds_msg_print_header(handle, stderr, " ");
return (-1);
}
}
return (0);
}
void ds_msg_decode_header(ds_msg_handle_t *handle,
void *in_msg)
{
DsMsgHdr_t hdr;
_check_init(handle);
memcpy(&hdr, in_msg, sizeof(DsMsgHdr_t));
BE_to_DsMsgHdr(&hdr);
handle->hdr.type = hdr.type;
handle->hdr.subType = hdr.subType;
handle->hdr.mode = hdr.mode;
handle->hdr.flags = hdr.flags;
handle->hdr.majorVersion = hdr.majorVersion;
handle->hdr.minorVersion = hdr.minorVersion;
handle->hdr.serialNum = hdr.serialNum;
handle->hdr.category = hdr.category;
handle->hdr.nParts = hdr.nParts;
}
ds_msg_part_t *ds_msg_get_part_by_type(ds_msg_handle_t *handle,
int data_type,
int index)
{
int i;
int count = 0;
_check_init(handle);
for (i = 0; i < handle->hdr.nParts; i++) {
if (handle->parts[i].type == data_type) {
if (count == index) {
return(handle->parts + i);
}
count++;
}
}
return (NULL);
}
//Modifiers for defaults
short mouse_move_delay(short delay) {
if (!_check_init()) {
return -1;
}
if(delay < 0) {
return defaults->mouse_move_delay;
}
if(defaults->mouse_move_delay > 0) {
char *msg = "The mouse used to pause at each pixel for %hu"
" milliseconds\n";
logit(LOG_LEVEL_EXTRA_VERBOSE, msg, defaults->mouse_move_delay);
} else {
logit(LOG_LEVEL_EXTRA_VERBOSE, "%s", "The mouse used to move instantly");
}
defaults->mouse_move_delay = delay;
if(defaults->mouse_move_delay > 0) {
char *msg = "The mouse now pauses at each pixel for %hu"
" milliseconds\n";
logit(LOG_LEVEL_EXTRA_VERBOSE, msg, defaults->mouse_move_delay);
} else {
logit(LOG_LEVEL_EXTRA_VERBOSE, "%s", "The mouse now moves instantly");
}
return defaults->mouse_move_delay;
}
void ds_msg_clear_parts(ds_msg_handle_t *handle)
{
_check_init(handle);
handle->hdr.nParts = 0;
}
ui08 *ds_msg_assemble(ds_msg_handle_t *handle)
{
int i;
int partHdrOffset;
int partDataOffset;
DsMsgHdr_t header;
_check_init(handle);
/* compute total message length */
handle->length_assembled = 0;
handle->length_assembled += sizeof(DsMsgHdr_t);
handle->length_assembled += handle->hdr.nParts * sizeof(DsMsgPart_t);
for (i = 0; i < handle->hdr.nParts; i++) {
handle->length_assembled += handle->parts[i].padded_length;
}
/* allocate memory */
_alloc_assembled_msg(handle);
/* load up header */
memset(&header, 0, sizeof(DsMsgHdr_t));
header.type = handle->hdr.type;
header.subType = handle->hdr.subType;
header.mode = handle->hdr.mode;
header.flags = handle->hdr.flags;
header.majorVersion = handle->hdr.majorVersion;
header.minorVersion = handle->hdr.minorVersion;
header.serialNum = handle->hdr.serialNum;
header.category = handle->hdr.category;
header.nParts = handle->hdr.nParts;
BE_from_DsMsgHdr(&header);
memcpy(handle->assembled_msg, &header, sizeof(DsMsgHdr_t));
/* load up parts */
partHdrOffset = sizeof(DsMsgHdr_t);
partDataOffset = partHdrOffset + handle->hdr.nParts * sizeof(DsMsgPart_t);
for (i = 0; i < handle->hdr.nParts; i++) {
DsMsgPart_t msgPart;
memset(&msgPart, 0, sizeof(DsMsgPart_t));
msgPart.dataType = handle->parts[i].type;
msgPart.len = handle->parts[i].length;
msgPart.offset = partDataOffset;
BE_from_DsMsgPart(&msgPart);
memcpy(handle->assembled_msg + partHdrOffset,
&msgPart, sizeof(DsMsgPart_t));
memcpy(handle->assembled_msg + partDataOffset,
handle->parts[i].buf, handle->parts[i].length);
partHdrOffset += sizeof(DsMsgPart_t);
partDataOffset += handle->parts[i].padded_length;
}
return (handle->assembled_msg);
}
void _mouse_xy(int *ret, Window win) {
if (!_check_init()) {
return;
}
Window query_window;
if(win == 0) {
query_window = DefaultRootWindow(defaults->display);
logit(LOG_LEVEL_EXTRA_VERBOSE, "%s", "Getting mouse xy against root window\n");
} else {
if(is_valid(win)) {
query_window = find_outer_parent(win);
logit(LOG_LEVEL_EXTRA_VERBOSE, "Getting mouse xy against window %lu\n", win);
} else {
fprintf(stderr, "Window %lu was not valid for xy -"
" returning absolute coordinates\n", win);
_mouse_xy(ret, 0);
return;
}
}
//Both root xy and window xy come along for the ride.
//Later we'll get the one we really want.
Window root_return_ignored;
Window child_return_ignored;
int rootx;
int rooty;
int winx;
int winy;
unsigned int mask_return_ignored;
int success =
XQueryPointer(
defaults->display,
query_window,
&root_return_ignored,
&child_return_ignored,
&rootx,
&rooty,
&winx,
&winy,
&mask_return_ignored);
if(success) {
if(is_valid(win)) {
logit(LOG_LEVEL_EXTRA_VERBOSE,
"Mouse is at %d X %d relative to window %lu\n",
winx, winy, win);
ret[0] = winx;
ret[1] = winy;
} else {
logit(LOG_LEVEL_EXTRA_VERBOSE,
"Mouse is at %d X %d relative to the root window\n",
winx, winy);
ret[0] = rootx;
ret[1] = rooty;
}
} else {
fprintf(stderr, "Query for mouse x and y failed. Returning %d\n", INT_MIN);
ret[0] = INT_MIN;
ret[1] = INT_MIN;
}
}
int display_w() {
if (!_check_init()) {
return -1;
}
return defaults->dsp_width;
}
int display_h() {
if (!_check_init()) {
return -1;
}
return defaults->dsp_height;
}
