##// END OF EJS Templates
chg: silence warning of unused parameter 'sig'
Yuya Nishihara -
r29440:009cc6c8 default
parent child Browse files
Show More
@@ -1,669 +1,669 b''
1 1 /*
2 2 * A fast client for Mercurial command server
3 3 *
4 4 * Copyright (c) 2011 Yuya Nishihara <yuya@tcha.org>
5 5 *
6 6 * This software may be used and distributed according to the terms of the
7 7 * GNU General Public License version 2 or any later version.
8 8 */
9 9
10 10 #include <assert.h>
11 11 #include <errno.h>
12 12 #include <fcntl.h>
13 13 #include <signal.h>
14 14 #include <stdio.h>
15 15 #include <stdlib.h>
16 16 #include <string.h>
17 17 #include <sys/file.h>
18 18 #include <sys/stat.h>
19 19 #include <sys/types.h>
20 20 #include <sys/un.h>
21 21 #include <sys/wait.h>
22 22 #include <time.h>
23 23 #include <unistd.h>
24 24
25 25 #include "hgclient.h"
26 26 #include "util.h"
27 27
28 28 #ifndef UNIX_PATH_MAX
29 29 #define UNIX_PATH_MAX (sizeof(((struct sockaddr_un *)NULL)->sun_path))
30 30 #endif
31 31
32 32 struct cmdserveropts {
33 33 char sockname[UNIX_PATH_MAX];
34 34 char redirectsockname[UNIX_PATH_MAX];
35 35 char lockfile[UNIX_PATH_MAX];
36 36 size_t argsize;
37 37 const char **args;
38 38 int lockfd;
39 39 int sockdirfd;
40 40 };
41 41
42 42 static void initcmdserveropts(struct cmdserveropts *opts) {
43 43 memset(opts, 0, sizeof(struct cmdserveropts));
44 44 opts->lockfd = -1;
45 45 opts->sockdirfd = -1;
46 46 }
47 47
48 48 static void freecmdserveropts(struct cmdserveropts *opts) {
49 49 free(opts->args);
50 50 opts->args = NULL;
51 51 opts->argsize = 0;
52 52 assert(opts->lockfd == -1 && "should be closed by unlockcmdserver()");
53 53 if (opts->sockdirfd >= 0) {
54 54 close(opts->sockdirfd);
55 55 opts->sockdirfd = -1;
56 56 }
57 57 }
58 58
59 59 /*
60 60 * Test if an argument is a sensitive flag that should be passed to the server.
61 61 * Return 0 if not, otherwise the number of arguments starting from the current
62 62 * one that should be passed to the server.
63 63 */
64 64 static size_t testsensitiveflag(const char *arg)
65 65 {
66 66 static const struct {
67 67 const char *name;
68 68 size_t narg;
69 69 } flags[] = {
70 70 {"--config", 1},
71 71 {"--cwd", 1},
72 72 {"--repo", 1},
73 73 {"--repository", 1},
74 74 {"--traceback", 0},
75 75 {"-R", 1},
76 76 };
77 77 size_t i;
78 78 for (i = 0; i < sizeof(flags) / sizeof(flags[0]); ++i) {
79 79 size_t len = strlen(flags[i].name);
80 80 size_t narg = flags[i].narg;
81 81 if (memcmp(arg, flags[i].name, len) == 0) {
82 82 if (arg[len] == '\0') {
83 83 /* --flag (value) */
84 84 return narg + 1;
85 85 } else if (arg[len] == '=' && narg > 0) {
86 86 /* --flag=value */
87 87 return 1;
88 88 } else if (flags[i].name[1] != '-') {
89 89 /* short flag */
90 90 return 1;
91 91 }
92 92 }
93 93 }
94 94 return 0;
95 95 }
96 96
97 97 /*
98 98 * Parse argv[] and put sensitive flags to opts->args
99 99 */
100 100 static void setcmdserverargs(struct cmdserveropts *opts,
101 101 int argc, const char *argv[])
102 102 {
103 103 size_t i, step;
104 104 opts->argsize = 0;
105 105 for (i = 0, step = 1; i < (size_t)argc; i += step, step = 1) {
106 106 if (!argv[i])
107 107 continue; /* pass clang-analyse */
108 108 if (strcmp(argv[i], "--") == 0)
109 109 break;
110 110 size_t n = testsensitiveflag(argv[i]);
111 111 if (n == 0 || i + n > (size_t)argc)
112 112 continue;
113 113 opts->args = reallocx(opts->args,
114 114 (n + opts->argsize) * sizeof(char *));
115 115 memcpy(opts->args + opts->argsize, argv + i,
116 116 sizeof(char *) * n);
117 117 opts->argsize += n;
118 118 step = n;
119 119 }
120 120 }
121 121
122 122 static void preparesockdir(const char *sockdir)
123 123 {
124 124 int r;
125 125 r = mkdir(sockdir, 0700);
126 126 if (r < 0 && errno != EEXIST)
127 127 abortmsgerrno("cannot create sockdir %s", sockdir);
128 128
129 129 struct stat st;
130 130 r = lstat(sockdir, &st);
131 131 if (r < 0)
132 132 abortmsgerrno("cannot stat %s", sockdir);
133 133 if (!S_ISDIR(st.st_mode))
134 134 abortmsg("cannot create sockdir %s (file exists)", sockdir);
135 135 if (st.st_uid != geteuid() || st.st_mode & 0077)
136 136 abortmsg("insecure sockdir %s", sockdir);
137 137 }
138 138
139 139 static void setcmdserveropts(struct cmdserveropts *opts)
140 140 {
141 141 int r;
142 142 char sockdir[UNIX_PATH_MAX];
143 143 const char *envsockname = getenv("CHGSOCKNAME");
144 144 if (!envsockname) {
145 145 /* by default, put socket file in secure directory
146 146 * (permission of socket file may be ignored on some Unices) */
147 147 const char *tmpdir = getenv("TMPDIR");
148 148 if (!tmpdir)
149 149 tmpdir = "/tmp";
150 150 r = snprintf(sockdir, sizeof(sockdir), "%s/chg%d",
151 151 tmpdir, geteuid());
152 152 if (r < 0 || (size_t)r >= sizeof(sockdir))
153 153 abortmsg("too long TMPDIR (r = %d)", r);
154 154 preparesockdir(sockdir);
155 155 }
156 156
157 157 const char *basename = (envsockname) ? envsockname : sockdir;
158 158 const char *sockfmt = (envsockname) ? "%s" : "%s/server";
159 159 const char *lockfmt = (envsockname) ? "%s.lock" : "%s/lock";
160 160 r = snprintf(opts->sockname, sizeof(opts->sockname), sockfmt, basename);
161 161 if (r < 0 || (size_t)r >= sizeof(opts->sockname))
162 162 abortmsg("too long TMPDIR or CHGSOCKNAME (r = %d)", r);
163 163 r = snprintf(opts->lockfile, sizeof(opts->lockfile), lockfmt, basename);
164 164 if (r < 0 || (size_t)r >= sizeof(opts->lockfile))
165 165 abortmsg("too long TMPDIR or CHGSOCKNAME (r = %d)", r);
166 166 }
167 167
168 168 /*
169 169 * Acquire a file lock that indicates a client is trying to start and connect
170 170 * to a server, before executing a command. The lock is released upon exit or
171 171 * explicit unlock. Will block if the lock is held by another process.
172 172 */
173 173 static void lockcmdserver(struct cmdserveropts *opts)
174 174 {
175 175 if (opts->lockfd == -1) {
176 176 opts->lockfd = open(opts->lockfile,
177 177 O_RDWR | O_CREAT | O_NOFOLLOW, 0600);
178 178 if (opts->lockfd == -1)
179 179 abortmsgerrno("cannot create lock file %s",
180 180 opts->lockfile);
181 181 fsetcloexec(opts->lockfd);
182 182 }
183 183 int r = flock(opts->lockfd, LOCK_EX);
184 184 if (r == -1)
185 185 abortmsgerrno("cannot acquire lock");
186 186 }
187 187
188 188 /*
189 189 * Release the file lock held by calling lockcmdserver. Will do nothing if
190 190 * lockcmdserver is not called.
191 191 */
192 192 static void unlockcmdserver(struct cmdserveropts *opts)
193 193 {
194 194 if (opts->lockfd == -1)
195 195 return;
196 196 flock(opts->lockfd, LOCK_UN);
197 197 close(opts->lockfd);
198 198 opts->lockfd = -1;
199 199 }
200 200
201 201 static const char *gethgcmd(void)
202 202 {
203 203 static const char *hgcmd = NULL;
204 204 if (!hgcmd) {
205 205 hgcmd = getenv("CHGHG");
206 206 if (!hgcmd || hgcmd[0] == '\0')
207 207 hgcmd = getenv("HG");
208 208 if (!hgcmd || hgcmd[0] == '\0')
209 209 #ifdef HGPATH
210 210 hgcmd = (HGPATH);
211 211 #else
212 212 hgcmd = "hg";
213 213 #endif
214 214 }
215 215 return hgcmd;
216 216 }
217 217
218 218 static void execcmdserver(const struct cmdserveropts *opts)
219 219 {
220 220 const char *hgcmd = gethgcmd();
221 221
222 222 const char *baseargv[] = {
223 223 hgcmd,
224 224 "serve",
225 225 "--cmdserver", "chgunix",
226 226 "--address", opts->sockname,
227 227 "--daemon-postexec", "chdir:/",
228 228 "--config", "extensions.chgserver=",
229 229 };
230 230 size_t baseargvsize = sizeof(baseargv) / sizeof(baseargv[0]);
231 231 size_t argsize = baseargvsize + opts->argsize + 1;
232 232
233 233 const char **argv = mallocx(sizeof(char *) * argsize);
234 234 memcpy(argv, baseargv, sizeof(baseargv));
235 235 memcpy(argv + baseargvsize, opts->args, sizeof(char *) * opts->argsize);
236 236 argv[argsize - 1] = NULL;
237 237
238 238 if (putenv("CHGINTERNALMARK=") != 0)
239 239 abortmsgerrno("failed to putenv");
240 240 if (execvp(hgcmd, (char **)argv) < 0)
241 241 abortmsgerrno("failed to exec cmdserver");
242 242 free(argv);
243 243 }
244 244
245 245 /* Retry until we can connect to the server. Give up after some time. */
246 246 static hgclient_t *retryconnectcmdserver(struct cmdserveropts *opts, pid_t pid)
247 247 {
248 248 static const struct timespec sleepreq = {0, 10 * 1000000};
249 249 int pst = 0;
250 250
251 251 debugmsg("try connect to %s repeatedly", opts->sockname);
252 252
253 253 unsigned int timeoutsec = 60; /* default: 60 seconds */
254 254 const char *timeoutenv = getenv("CHGTIMEOUT");
255 255 if (timeoutenv)
256 256 sscanf(timeoutenv, "%u", &timeoutsec);
257 257
258 258 for (unsigned int i = 0; !timeoutsec || i < timeoutsec * 100; i++) {
259 259 hgclient_t *hgc = hgc_open(opts->sockname);
260 260 if (hgc)
261 261 return hgc;
262 262
263 263 if (pid > 0) {
264 264 /* collect zombie if child process fails to start */
265 265 int r = waitpid(pid, &pst, WNOHANG);
266 266 if (r != 0)
267 267 goto cleanup;
268 268 }
269 269
270 270 nanosleep(&sleepreq, NULL);
271 271 }
272 272
273 273 abortmsg("timed out waiting for cmdserver %s", opts->sockname);
274 274 return NULL;
275 275
276 276 cleanup:
277 277 if (WIFEXITED(pst)) {
278 278 if (WEXITSTATUS(pst) == 0)
279 279 abortmsg("could not connect to cmdserver "
280 280 "(exited with status 0)");
281 281 debugmsg("cmdserver exited with status %d", WEXITSTATUS(pst));
282 282 exit(WEXITSTATUS(pst));
283 283 } else if (WIFSIGNALED(pst)) {
284 284 abortmsg("cmdserver killed by signal %d", WTERMSIG(pst));
285 285 } else {
286 286 abortmsg("error while waiting for cmdserver");
287 287 }
288 288 return NULL;
289 289 }
290 290
291 291 /* Connect to a cmdserver. Will start a new server on demand. */
292 292 static hgclient_t *connectcmdserver(struct cmdserveropts *opts)
293 293 {
294 294 const char *sockname = opts->redirectsockname[0] ?
295 295 opts->redirectsockname : opts->sockname;
296 296 debugmsg("try connect to %s", sockname);
297 297 hgclient_t *hgc = hgc_open(sockname);
298 298 if (hgc)
299 299 return hgc;
300 300
301 301 lockcmdserver(opts);
302 302 hgc = hgc_open(sockname);
303 303 if (hgc) {
304 304 unlockcmdserver(opts);
305 305 debugmsg("cmdserver is started by another process");
306 306 return hgc;
307 307 }
308 308
309 309 /* prevent us from being connected to an outdated server: we were
310 310 * told by a server to redirect to opts->redirectsockname and that
311 311 * address does not work. we do not want to connect to the server
312 312 * again because it will probably tell us the same thing. */
313 313 if (sockname == opts->redirectsockname)
314 314 unlink(opts->sockname);
315 315
316 316 debugmsg("start cmdserver at %s", opts->sockname);
317 317
318 318 pid_t pid = fork();
319 319 if (pid < 0)
320 320 abortmsg("failed to fork cmdserver process");
321 321 if (pid == 0) {
322 322 execcmdserver(opts);
323 323 } else {
324 324 hgc = retryconnectcmdserver(opts, pid);
325 325 }
326 326
327 327 unlockcmdserver(opts);
328 328 return hgc;
329 329 }
330 330
331 331 static void killcmdserver(const struct cmdserveropts *opts)
332 332 {
333 333 /* resolve config hash */
334 334 char *resolvedpath = realpath(opts->sockname, NULL);
335 335 if (resolvedpath) {
336 336 unlink(resolvedpath);
337 337 free(resolvedpath);
338 338 }
339 339 }
340 340
341 341 static pid_t pagerpid = 0;
342 342 static pid_t peerpid = 0;
343 343
344 344 static void forwardsignal(int sig)
345 345 {
346 346 assert(peerpid > 0);
347 347 if (kill(peerpid, sig) < 0)
348 348 abortmsgerrno("cannot kill %d", peerpid);
349 349 debugmsg("forward signal %d", sig);
350 350 }
351 351
352 352 static void handlestopsignal(int sig)
353 353 {
354 354 sigset_t unblockset, oldset;
355 355 struct sigaction sa, oldsa;
356 356 if (sigemptyset(&unblockset) < 0)
357 357 goto error;
358 358 if (sigaddset(&unblockset, sig) < 0)
359 359 goto error;
360 360 memset(&sa, 0, sizeof(sa));
361 361 sa.sa_handler = SIG_DFL;
362 362 sa.sa_flags = SA_RESTART;
363 363 if (sigemptyset(&sa.sa_mask) < 0)
364 364 goto error;
365 365
366 366 forwardsignal(sig);
367 367 if (raise(sig) < 0) /* resend to self */
368 368 goto error;
369 369 if (sigaction(sig, &sa, &oldsa) < 0)
370 370 goto error;
371 371 if (sigprocmask(SIG_UNBLOCK, &unblockset, &oldset) < 0)
372 372 goto error;
373 373 /* resent signal will be handled before sigprocmask() returns */
374 374 if (sigprocmask(SIG_SETMASK, &oldset, NULL) < 0)
375 375 goto error;
376 376 if (sigaction(sig, &oldsa, NULL) < 0)
377 377 goto error;
378 378 return;
379 379
380 380 error:
381 381 abortmsgerrno("failed to handle stop signal");
382 382 }
383 383
384 static void handlechildsignal(int sig)
384 static void handlechildsignal(int sig UNUSED_)
385 385 {
386 386 if (peerpid == 0 || pagerpid == 0)
387 387 return;
388 388 /* if pager exits, notify the server with SIGPIPE immediately.
389 389 * otherwise the server won't get SIGPIPE if it does not write
390 390 * anything. (issue5278) */
391 391 if (waitpid(pagerpid, NULL, WNOHANG) == pagerpid)
392 392 kill(peerpid, SIGPIPE);
393 393 }
394 394
395 395 static void setupsignalhandler(pid_t pid)
396 396 {
397 397 if (pid <= 0)
398 398 return;
399 399 peerpid = pid;
400 400
401 401 struct sigaction sa;
402 402 memset(&sa, 0, sizeof(sa));
403 403 sa.sa_handler = forwardsignal;
404 404 sa.sa_flags = SA_RESTART;
405 405 if (sigemptyset(&sa.sa_mask) < 0)
406 406 goto error;
407 407
408 408 if (sigaction(SIGHUP, &sa, NULL) < 0)
409 409 goto error;
410 410 if (sigaction(SIGINT, &sa, NULL) < 0)
411 411 goto error;
412 412
413 413 /* terminate frontend by double SIGTERM in case of server freeze */
414 414 sa.sa_flags |= SA_RESETHAND;
415 415 if (sigaction(SIGTERM, &sa, NULL) < 0)
416 416 goto error;
417 417
418 418 /* notify the worker about window resize events */
419 419 sa.sa_flags = SA_RESTART;
420 420 if (sigaction(SIGWINCH, &sa, NULL) < 0)
421 421 goto error;
422 422 /* propagate job control requests to worker */
423 423 sa.sa_handler = forwardsignal;
424 424 sa.sa_flags = SA_RESTART;
425 425 if (sigaction(SIGCONT, &sa, NULL) < 0)
426 426 goto error;
427 427 sa.sa_handler = handlestopsignal;
428 428 sa.sa_flags = SA_RESTART;
429 429 if (sigaction(SIGTSTP, &sa, NULL) < 0)
430 430 goto error;
431 431 /* get notified when pager exits */
432 432 sa.sa_handler = handlechildsignal;
433 433 sa.sa_flags = SA_RESTART;
434 434 if (sigaction(SIGCHLD, &sa, NULL) < 0)
435 435 goto error;
436 436
437 437 return;
438 438
439 439 error:
440 440 abortmsgerrno("failed to set up signal handlers");
441 441 }
442 442
443 443 static void restoresignalhandler()
444 444 {
445 445 struct sigaction sa;
446 446 memset(&sa, 0, sizeof(sa));
447 447 sa.sa_handler = SIG_DFL;
448 448 sa.sa_flags = SA_RESTART;
449 449 if (sigemptyset(&sa.sa_mask) < 0)
450 450 goto error;
451 451
452 452 if (sigaction(SIGHUP, &sa, NULL) < 0)
453 453 goto error;
454 454 if (sigaction(SIGTERM, &sa, NULL) < 0)
455 455 goto error;
456 456 if (sigaction(SIGWINCH, &sa, NULL) < 0)
457 457 goto error;
458 458 if (sigaction(SIGCONT, &sa, NULL) < 0)
459 459 goto error;
460 460 if (sigaction(SIGTSTP, &sa, NULL) < 0)
461 461 goto error;
462 462 if (sigaction(SIGCHLD, &sa, NULL) < 0)
463 463 goto error;
464 464
465 465 /* ignore Ctrl+C while shutting down to make pager exits cleanly */
466 466 sa.sa_handler = SIG_IGN;
467 467 if (sigaction(SIGINT, &sa, NULL) < 0)
468 468 goto error;
469 469
470 470 peerpid = 0;
471 471 return;
472 472
473 473 error:
474 474 abortmsgerrno("failed to restore signal handlers");
475 475 }
476 476
477 477 /* This implementation is based on hgext/pager.py (post 369741ef7253)
478 478 * Return 0 if pager is not started, or pid of the pager */
479 479 static pid_t setuppager(hgclient_t *hgc, const char *const args[],
480 480 size_t argsize)
481 481 {
482 482 const char *pagercmd = hgc_getpager(hgc, args, argsize);
483 483 if (!pagercmd)
484 484 return 0;
485 485
486 486 int pipefds[2];
487 487 if (pipe(pipefds) < 0)
488 488 return 0;
489 489 pid_t pid = fork();
490 490 if (pid < 0)
491 491 goto error;
492 492 if (pid > 0) {
493 493 close(pipefds[0]);
494 494 if (dup2(pipefds[1], fileno(stdout)) < 0)
495 495 goto error;
496 496 if (isatty(fileno(stderr))) {
497 497 if (dup2(pipefds[1], fileno(stderr)) < 0)
498 498 goto error;
499 499 }
500 500 close(pipefds[1]);
501 501 hgc_attachio(hgc); /* reattach to pager */
502 502 return pid;
503 503 } else {
504 504 dup2(pipefds[0], fileno(stdin));
505 505 close(pipefds[0]);
506 506 close(pipefds[1]);
507 507
508 508 int r = execlp("/bin/sh", "/bin/sh", "-c", pagercmd, NULL);
509 509 if (r < 0) {
510 510 abortmsgerrno("cannot start pager '%s'", pagercmd);
511 511 }
512 512 return 0;
513 513 }
514 514
515 515 error:
516 516 close(pipefds[0]);
517 517 close(pipefds[1]);
518 518 abortmsgerrno("failed to prepare pager");
519 519 return 0;
520 520 }
521 521
522 522 static void waitpager(pid_t pid)
523 523 {
524 524 /* close output streams to notify the pager its input ends */
525 525 fclose(stdout);
526 526 fclose(stderr);
527 527 while (1) {
528 528 pid_t ret = waitpid(pid, NULL, 0);
529 529 if (ret == -1 && errno == EINTR)
530 530 continue;
531 531 break;
532 532 }
533 533 }
534 534
535 535 /* Run instructions sent from the server like unlink and set redirect path
536 536 * Return 1 if reconnect is needed, otherwise 0 */
537 537 static int runinstructions(struct cmdserveropts *opts, const char **insts)
538 538 {
539 539 int needreconnect = 0;
540 540 if (!insts)
541 541 return needreconnect;
542 542
543 543 assert(insts);
544 544 opts->redirectsockname[0] = '\0';
545 545 const char **pinst;
546 546 for (pinst = insts; *pinst; pinst++) {
547 547 debugmsg("instruction: %s", *pinst);
548 548 if (strncmp(*pinst, "unlink ", 7) == 0) {
549 549 unlink(*pinst + 7);
550 550 } else if (strncmp(*pinst, "redirect ", 9) == 0) {
551 551 int r = snprintf(opts->redirectsockname,
552 552 sizeof(opts->redirectsockname),
553 553 "%s", *pinst + 9);
554 554 if (r < 0 || r >= (int)sizeof(opts->redirectsockname))
555 555 abortmsg("redirect path is too long (%d)", r);
556 556 needreconnect = 1;
557 557 } else if (strncmp(*pinst, "exit ", 5) == 0) {
558 558 int n = 0;
559 559 if (sscanf(*pinst + 5, "%d", &n) != 1)
560 560 abortmsg("cannot read the exit code");
561 561 exit(n);
562 562 } else if (strcmp(*pinst, "reconnect") == 0) {
563 563 needreconnect = 1;
564 564 } else {
565 565 abortmsg("unknown instruction: %s", *pinst);
566 566 }
567 567 }
568 568 return needreconnect;
569 569 }
570 570
571 571 /*
572 572 * Test whether the command is unsupported or not. This is not designed to
573 573 * cover all cases. But it's fast, does not depend on the server and does
574 574 * not return false positives.
575 575 */
576 576 static int isunsupported(int argc, const char *argv[])
577 577 {
578 578 enum {
579 579 SERVE = 1,
580 580 DAEMON = 2,
581 581 SERVEDAEMON = SERVE | DAEMON,
582 582 TIME = 4,
583 583 };
584 584 unsigned int state = 0;
585 585 int i;
586 586 for (i = 0; i < argc; ++i) {
587 587 if (strcmp(argv[i], "--") == 0)
588 588 break;
589 589 if (i == 0 && strcmp("serve", argv[i]) == 0)
590 590 state |= SERVE;
591 591 else if (strcmp("-d", argv[i]) == 0 ||
592 592 strcmp("--daemon", argv[i]) == 0)
593 593 state |= DAEMON;
594 594 else if (strcmp("--time", argv[i]) == 0)
595 595 state |= TIME;
596 596 }
597 597 return (state & TIME) == TIME ||
598 598 (state & SERVEDAEMON) == SERVEDAEMON;
599 599 }
600 600
601 601 static void execoriginalhg(const char *argv[])
602 602 {
603 603 debugmsg("execute original hg");
604 604 if (execvp(gethgcmd(), (char **)argv) < 0)
605 605 abortmsgerrno("failed to exec original hg");
606 606 }
607 607
608 608 int main(int argc, const char *argv[], const char *envp[])
609 609 {
610 610 if (getenv("CHGDEBUG"))
611 611 enabledebugmsg();
612 612
613 613 if (!getenv("HGPLAIN") && isatty(fileno(stderr)))
614 614 enablecolor();
615 615
616 616 if (getenv("CHGINTERNALMARK"))
617 617 abortmsg("chg started by chg detected.\n"
618 618 "Please make sure ${HG:-hg} is not a symlink or "
619 619 "wrapper to chg. Alternatively, set $CHGHG to the "
620 620 "path of real hg.");
621 621
622 622 if (isunsupported(argc - 1, argv + 1))
623 623 execoriginalhg(argv);
624 624
625 625 struct cmdserveropts opts;
626 626 initcmdserveropts(&opts);
627 627 setcmdserveropts(&opts);
628 628 setcmdserverargs(&opts, argc, argv);
629 629
630 630 if (argc == 2) {
631 631 if (strcmp(argv[1], "--kill-chg-daemon") == 0) {
632 632 killcmdserver(&opts);
633 633 return 0;
634 634 }
635 635 }
636 636
637 637 hgclient_t *hgc;
638 638 size_t retry = 0;
639 639 while (1) {
640 640 hgc = connectcmdserver(&opts);
641 641 if (!hgc)
642 642 abortmsg("cannot open hg client");
643 643 hgc_setenv(hgc, envp);
644 644 const char **insts = hgc_validate(hgc, argv + 1, argc - 1);
645 645 int needreconnect = runinstructions(&opts, insts);
646 646 free(insts);
647 647 if (!needreconnect)
648 648 break;
649 649 hgc_close(hgc);
650 650 if (++retry > 10)
651 651 abortmsg("too many redirections.\n"
652 652 "Please make sure %s is not a wrapper which "
653 653 "changes sensitive environment variables "
654 654 "before executing hg. If you have to use a "
655 655 "wrapper, wrap chg instead of hg.",
656 656 gethgcmd());
657 657 }
658 658
659 659 setupsignalhandler(hgc_peerpid(hgc));
660 660 pagerpid = setuppager(hgc, argv + 1, argc - 1);
661 661 int exitcode = hgc_runcommand(hgc, argv + 1, argc - 1);
662 662 restoresignalhandler();
663 663 hgc_close(hgc);
664 664 freecmdserveropts(&opts);
665 665 if (pagerpid)
666 666 waitpager(pagerpid);
667 667
668 668 return exitcode;
669 669 }
@@ -1,33 +1,35 b''
1 1 /*
2 2 * Utility functions
3 3 *
4 4 * Copyright (c) 2011 Yuya Nishihara <yuya@tcha.org>
5 5 *
6 6 * This software may be used and distributed according to the terms of the
7 7 * GNU General Public License version 2 or any later version.
8 8 */
9 9
10 10 #ifndef UTIL_H_
11 11 #define UTIL_H_
12 12
13 13 #ifdef __GNUC__
14 14 #define PRINTF_FORMAT_ __attribute__((format(printf, 1, 2)))
15 #define UNUSED_ __attribute__((unused))
15 16 #else
16 17 #define PRINTF_FORMAT_
18 #define UNUSED_
17 19 #endif
18 20
19 21 void abortmsg(const char *fmt, ...) PRINTF_FORMAT_;
20 22 void abortmsgerrno(const char *fmt, ...) PRINTF_FORMAT_;
21 23
22 24 void enablecolor(void);
23 25 void enabledebugmsg(void);
24 26 void debugmsg(const char *fmt, ...) PRINTF_FORMAT_;
25 27
26 28 void fchdirx(int dirfd);
27 29 void fsetcloexec(int fd);
28 30 void *mallocx(size_t size);
29 31 void *reallocx(void *ptr, size_t size);
30 32
31 33 int runshellcmd(const char *cmd, const char *envp[], const char *cwd);
32 34
33 35 #endif /* UTIL_H_ */
General Comments 0
You need to be logged in to leave comments. Login now