1 /* vi:set ts=8 sts=4 sw=4: 2 * 3 * VIM - Vi IMproved by Bram Moolenaar 4 * X-Windows communication by Flemming Madsen 5 * 6 * Do ":help uganda" in Vim to read copying and usage conditions. 7 * Do ":help credits" in Vim to see a list of people who contributed. 8 * See README.txt for an overview of the Vim source code. 9 * 10 * Client for sending commands to an '+xcmdsrv' enabled vim. 11 * This is mostly a de-Vimified version of if_xcmdsrv.c in vim. 12 * See that file for a protocol specification. 13 * 14 * You can make a test program with a Makefile like: 15 * xcmdsrv_client: xcmdsrv_client.c 16 * cc -o $@ -g -DMAIN -I/usr/X11R6/include -L/usr/X11R6/lib $< -lX11 17 * 18 */ 19 20 #include <stdio.h> 21 #include <string.h> 22 #ifdef HAVE_SELECT 23 #include <sys/time.h> 24 #include <sys/types.h> 25 #include <unistd.h> 26 #else 27 #include <sys/poll.h> 28 #endif 29 #include <X11/Intrinsic.h> 30 #include <X11/Xatom.h> 31 32 #define __ARGS(x) x 33 34 /* Client API */ 35 char * sendToVim __ARGS((Display *dpy, char *name, char *cmd, int asKeys, int *code)); 36 37 #ifdef MAIN 38 /* A sample program */ 39 main(int argc, char **argv) 40 { 41 char *res; 42 int code; 43 44 if (argc == 4) 45 { 46 if ((res = sendToVim(XOpenDisplay(NULL), argv[2], argv[3], 47 argv[1][0] != 'e', &code)) != NULL) 48 { 49 if (code) 50 printf("Error code returned: %d\n", code); 51 puts(res); 52 } 53 exit(0); 54 } 55 else 56 fprintf(stderr, "Usage: %s {k|e} <server> <command>", argv[0]); 57 58 exit(1); 59 } 60 #endif 61 62 /* 63 * Maximum size property that can be read at one time by 64 * this module: 65 */ 66 67 #define MAX_PROP_WORDS 100000 68 69 /* 70 * Forward declarations for procedures defined later in this file: 71 */ 72 73 static int x_error_check __ARGS((Display *dpy, XErrorEvent *error_event)); 74 static int AppendPropCarefully __ARGS((Display *display, 75 Window window, Atom property, char *value, int length)); 76 static Window LookupName __ARGS((Display *dpy, char *name, 77 int delete, char **loose)); 78 static int SendInit __ARGS((Display *dpy)); 79 static char *SendEventProc __ARGS((Display *dpy, XEvent *eventPtr, 80 int expect, int *code)); 81 static int IsSerialName __ARGS((char *name)); 82 83 /* Private variables */ 84 static Atom registryProperty = None; 85 static Atom commProperty = None; 86 static Window commWindow = None; 87 static int got_x_error = FALSE; 88 89 90 /* 91 * sendToVim -- 92 * Send to an instance of Vim via the X display. 93 * 94 * Results: 95 * A string with the result or NULL. Caller must free if non-NULL 96 */ 97 98 char * 99 sendToVim(dpy, name, cmd, asKeys, code) 100 Display *dpy; /* Where to send. */ 101 char *name; /* Where to send. */ 102 char *cmd; /* What to send. */ 103 int asKeys; /* Interpret as keystrokes or expr ? */ 104 int *code; /* Return code. 0 => OK */ 105 { 106 Window w; 107 Atom *plist; 108 XErrorHandler old_handler; 109 #define STATIC_SPACE 500 110 char *property, staticSpace[STATIC_SPACE]; 111 int length; 112 int res; 113 static int serial = 0; /* Running count of sent commands. 114 * Used to give each command a 115 * different serial number. */ 116 XEvent event; 117 XPropertyEvent *e = (XPropertyEvent *)&event; 118 time_t start; 119 char *result; 120 char *loosename = NULL; 121 122 if (commProperty == None && dpy != NULL) 123 { 124 if (SendInit(dpy) < 0) 125 return NULL; 126 } 127 128 /* 129 * Bind the server name to a communication window. 130 * 131 * Find any survivor with a serialno attached to the name if the 132 * original registrant of the wanted name is no longer present. 133 * 134 * Delete any lingering names from dead editors. 135 */ 136 137 old_handler = XSetErrorHandler(x_error_check); 138 while (TRUE) 139 { 140 got_x_error = FALSE; 141 w = LookupName(dpy, name, 0, &loosename); 142 /* Check that the window is hot */ 143 if (w != None) 144 { 145 plist = XListProperties(dpy, w, &res); 146 XSync(dpy, False); 147 if (plist != NULL) 148 XFree(plist); 149 if (got_x_error) 150 { 151 LookupName(dpy, loosename ? loosename : name, 152 /*DELETE=*/TRUE, NULL); 153 continue; 154 } 155 } 156 break; 157 } 158 if (w == None) 159 { 160 fprintf(stderr, "no registered server named %s\n", name); 161 return NULL; 162 } 163 else if (loosename != NULL) 164 name = loosename; 165 166 /* 167 * Send the command to target interpreter by appending it to the 168 * comm window in the communication window. 169 */ 170 171 length = strlen(name) + strlen(cmd) + 10; 172 if (length <= STATIC_SPACE) 173 property = staticSpace; 174 else 175 property = (char *) malloc((unsigned) length); 176 177 serial++; 178 sprintf(property, "%c%c%c-n %s%c-s %s", 179 0, asKeys ? 'k' : 'c', 0, name, 0, cmd); 180 if (name == loosename) 181 free(loosename); 182 if (!asKeys) 183 { 184 /* Add a back reference to our comm window */ 185 sprintf(property + length, "%c-r %x %d", 0, (uint) commWindow, serial); 186 length += strlen(property + length + 1) + 1; 187 } 188 189 res = AppendPropCarefully(dpy, w, commProperty, property, length + 1); 190 if (length > STATIC_SPACE) 191 free(property); 192 if (res < 0) 193 { 194 fprintf(stderr, "Failed to send command to the destination program\n"); 195 return NULL; 196 } 197 198 if (asKeys) /* There is no answer for this - Keys are sent async */ 199 return NULL; 200 201 202 /* 203 * Enter a loop processing X events & pooling chars until we see the result 204 */ 205 206 #define SEND_MSEC_POLL 50 207 208 time(&start); 209 while ((time((time_t *) 0) - start) < 60) 210 { 211 /* Look out for the answer */ 212 #ifndef HAVE_SELECT 213 struct pollfd fds; 214 215 fds.fd = ConnectionNumber(dpy); 216 fds.events = POLLIN; 217 if (poll(&fds, 1, SEND_MSEC_POLL) < 0) 218 break; 219 #else 220 fd_set fds; 221 struct timeval tv; 222 223 tv.tv_sec = 0; 224 tv.tv_usec = SEND_MSEC_POLL * 1000; 225 FD_ZERO(&fds); 226 FD_SET(ConnectionNumber(dpy), &fds); 227 if (select(ConnectionNumber(dpy) + 1, &fds, NULL, NULL, &tv) < 0) 228 break; 229 #endif 230 while (XEventsQueued(dpy, QueuedAfterReading) > 0) 231 { 232 XNextEvent(dpy, &event); 233 if (event.type == PropertyNotify && e->window == commWindow) 234 if ((result = SendEventProc(dpy, &event, serial, code)) != NULL) 235 return result; 236 } 237 } 238 return NULL; 239 } 240 241 242 /* 243 * SendInit -- 244 * This procedure is called to initialize the 245 * communication channels for sending commands and 246 * receiving results. 247 */ 248 249 static int 250 SendInit(dpy) 251 Display *dpy; 252 { 253 XErrorHandler old_handler; 254 255 /* 256 * Create the window used for communication, and set up an 257 * event handler for it. 258 */ 259 old_handler = XSetErrorHandler(x_error_check); 260 got_x_error = FALSE; 261 262 commProperty = XInternAtom(dpy, "Comm", False); 263 /* Change this back to "InterpRegistry" to talk to tk processes */ 264 registryProperty = XInternAtom(dpy, "VimRegistry", False); 265 266 if (commWindow == None) 267 { 268 commWindow = 269 XCreateSimpleWindow(dpy, XDefaultRootWindow(dpy), 270 getpid(), 0, 10, 10, 0, 271 WhitePixel(dpy, DefaultScreen(dpy)), 272 WhitePixel(dpy, DefaultScreen(dpy))); 273 XSelectInput(dpy, commWindow, PropertyChangeMask); 274 } 275 276 XSync(dpy, False); 277 (void) XSetErrorHandler(old_handler); 278 279 return got_x_error ? -1 : 0; 280 } 281 282 /* 283 * LookupName -- 284 * Given an interpreter name, see if the name exists in 285 * the interpreter registry for a particular display. 286 * 287 * Results: 288 * If the given name is registered, return the ID of 289 * the window associated with the name. If the name 290 * isn't registered, then return 0. 291 */ 292 293 static Window 294 LookupName(dpy, name, delete, loose) 295 Display *dpy; /* Display whose registry to check. */ 296 char *name; /* Name of an interpreter. */ 297 int delete; /* If non-zero, delete info about name. */ 298 char **loose; /* Do another search matching -999 if not found 299 Return result here if a match is found */ 300 { 301 unsigned char *regProp, *entry; 302 unsigned char *p; 303 int result, actualFormat; 304 unsigned long numItems, bytesAfter; 305 Atom actualType; 306 Window returnValue; 307 308 /* 309 * Read the registry property. 310 */ 311 312 regProp = NULL; 313 result = XGetWindowProperty(dpy, RootWindow(dpy, 0), registryProperty, 0, 314 MAX_PROP_WORDS, False, XA_STRING, &actualType, 315 &actualFormat, &numItems, &bytesAfter, 316 ®Prop); 317 318 if (actualType == None) 319 return 0; 320 321 /* 322 * If the property is improperly formed, then delete it. 323 */ 324 325 if ((result != Success) || (actualFormat != 8) || (actualType != XA_STRING)) 326 { 327 if (regProp != NULL) 328 XFree(regProp); 329 XDeleteProperty(dpy, RootWindow(dpy, 0), registryProperty); 330 return 0; 331 } 332 333 /* 334 * Scan the property for the desired name. 335 */ 336 337 returnValue = None; 338 entry = NULL; /* Not needed, but eliminates compiler warning. */ 339 for (p = regProp; (p - regProp) < numItems; ) 340 { 341 entry = p; 342 while ((*p != 0) && (!isspace(*p))) 343 p++; 344 if ((*p != 0) && (strcasecmp(name, p + 1) == 0)) 345 { 346 sscanf(entry, "%x", (uint*) &returnValue); 347 break; 348 } 349 while (*p != 0) 350 p++; 351 p++; 352 } 353 354 if (loose != NULL && returnValue == None && !IsSerialName(name)) 355 { 356 for (p = regProp; (p - regProp) < numItems; ) 357 { 358 entry = p; 359 while ((*p != 0) && (!isspace(*p))) 360 p++; 361 if ((*p != 0) && IsSerialName(p + 1) 362 && (strncmp(name, p + 1, strlen(name)) == 0)) 363 { 364 sscanf(entry, "%x", (uint*) &returnValue); 365 *loose = strdup(p + 1); 366 break; 367 } 368 while (*p != 0) 369 p++; 370 p++; 371 } 372 } 373 374 /* 375 * Delete the property, if that is desired (copy down the 376 * remainder of the registry property to overlay the deleted 377 * info, then rewrite the property). 378 */ 379 380 if ((delete) && (returnValue != None)) 381 { 382 int count; 383 384 while (*p != 0) 385 p++; 386 p++; 387 count = numItems - (p-regProp); 388 if (count > 0) 389 memcpy(entry, p, count); 390 XChangeProperty(dpy, RootWindow(dpy, 0), registryProperty, XA_STRING, 391 8, PropModeReplace, regProp, 392 (int) (numItems - (p-entry))); 393 XSync(dpy, False); 394 } 395 396 XFree(regProp); 397 return returnValue; 398 } 399 400 static char * 401 SendEventProc(dpy, eventPtr, expected, code) 402 Display *dpy; 403 XEvent *eventPtr; /* Information about event. */ 404 int expected; /* The one were waiting for */ 405 int *code; /* Return code. 0 => OK */ 406 { 407 unsigned char *propInfo; 408 unsigned char *p; 409 int result, actualFormat; 410 int retCode; 411 unsigned long numItems, bytesAfter; 412 Atom actualType; 413 414 if ((eventPtr->xproperty.atom != commProperty) 415 || (eventPtr->xproperty.state != PropertyNewValue)) 416 { 417 return; 418 } 419 420 /* 421 * Read the comm property and delete it. 422 */ 423 424 propInfo = NULL; 425 result = XGetWindowProperty(dpy, commWindow, commProperty, 0, 426 MAX_PROP_WORDS, True, XA_STRING, &actualType, 427 &actualFormat, &numItems, &bytesAfter, 428 &propInfo); 429 430 /* 431 * If the property doesn't exist or is improperly formed 432 * then ignore it. 433 */ 434 435 if ((result != Success) || (actualType != XA_STRING) 436 || (actualFormat != 8)) 437 { 438 if (propInfo != NULL) 439 { 440 XFree(propInfo); 441 } 442 return; 443 } 444 445 /* 446 * Several commands and results could arrive in the property at 447 * one time; each iteration through the outer loop handles a 448 * single command or result. 449 */ 450 451 for (p = propInfo; (p - propInfo) < numItems; ) 452 { 453 /* 454 * Ignore leading NULs; each command or result starts with a 455 * NUL so that no matter how badly formed a preceding command 456 * is, we'll be able to tell that a new command/result is 457 * starting. 458 */ 459 460 if (*p == 0) 461 { 462 p++; 463 continue; 464 } 465 466 if ((*p == 'r') && (p[1] == 0)) 467 { 468 int serial, gotSerial; 469 char *res; 470 471 /* 472 * This is a reply to some command that we sent out. Iterate 473 * over all of its options. Stop when we reach the end of the 474 * property or something that doesn't look like an option. 475 */ 476 477 p += 2; 478 gotSerial = 0; 479 res = ""; 480 retCode = 0; 481 while (((p-propInfo) < numItems) && (*p == '-')) 482 { 483 switch (p[1]) 484 { 485 case 'r': 486 if (p[2] == ' ') 487 res = p + 3; 488 break; 489 case 's': 490 if (sscanf(p + 2, " %d", &serial) == 1) 491 gotSerial = 1; 492 break; 493 case 'c': 494 if (sscanf(p + 2, " %d", &retCode) != 1) 495 retCode = 0; 496 break; 497 } 498 while (*p != 0) 499 p++; 500 p++; 501 } 502 503 if (!gotSerial) 504 continue; 505 506 if (code != NULL) 507 *code = retCode; 508 return serial == expected ? strdup(res) : NULL; 509 } 510 else 511 { 512 /* 513 * Didn't recognize this thing. Just skip through the next 514 * null character and try again. 515 * Also, throw away commands that we cant process anyway. 516 */ 517 518 while (*p != 0) 519 p++; 520 p++; 521 } 522 } 523 XFree(propInfo); 524 } 525 526 /* 527 * AppendPropCarefully -- 528 * 529 * Append a given property to a given window, but set up 530 * an X error handler so that if the append fails this 531 * procedure can return an error code rather than having 532 * Xlib panic. 533 * 534 * Return: 535 * 0 on OK - -1 on error 536 *-------------------------------------------------------------- 537 */ 538 539 static int 540 AppendPropCarefully(dpy, window, property, value, length) 541 Display *dpy; /* Display on which to operate. */ 542 Window window; /* Window whose property is to 543 * be modified. */ 544 Atom property; /* Name of property. */ 545 char *value; /* Characters to append to property. */ 546 int length; /* How much to append */ 547 { 548 XErrorHandler old_handler; 549 550 old_handler = XSetErrorHandler(x_error_check); 551 got_x_error = FALSE; 552 XChangeProperty(dpy, window, property, XA_STRING, 8, 553 PropModeAppend, value, length); 554 XSync(dpy, False); 555 (void) XSetErrorHandler(old_handler); 556 return got_x_error ? -1 : 0; 557 } 558 559 560 /* 561 * Another X Error handler, just used to check for errors. 562 */ 563 /* ARGSUSED */ 564 static int 565 x_error_check(dpy, error_event) 566 Display *dpy; 567 XErrorEvent *error_event; 568 { 569 got_x_error = TRUE; 570 return 0; 571 } 572 573 /* 574 * Check if "str" looks like it had a serial number appended. 575 * Actually just checks if the name ends in a digit. 576 */ 577 static int 578 IsSerialName(str) 579 char *str; 580 { 581 int len = strlen(str); 582 583 return (len > 1 && isdigit(str[len - 1])); 584 } 585