src/socket.c

   1 /* Copyright (c) 1993-2002
   2  *      Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
   3  *      Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de)
   4  * Copyright (c) 1987 Oliver Laumann
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2, or (at your option)
   9  * any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program (see the file COPYING); if not, write to the
  18  * Free Software Foundation, Inc.,
  19  * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
  20  *
  21  ****************************************************************
  22  */
  23
  24 #include "config.h"
  25 #include <sys/types.h>
  26 #include <sys/stat.h>
  27 #include <fcntl.h>
  28 #if !defined(NAMEDPIPE)
  29 #include <sys/socket.h>
  30 #include <sys/un.h>
  31 #endif
  32
  33 #ifndef SIGINT
  34 # include <signal.h>
  35 #endif
  36
  37 #include "screen.h"
  38
  39 #ifdef HAVE_DIRENT_H
  40 # include <dirent.h>
  41 #else
  42 # include <sys/dir.h>
  43 # define dirent direct
  44 #endif
  45
  46 #include "extern.h"
  47
  48 static int   CheckPid __P((int));
  49 static void  ExecCreate __P((struct msg *));
  50 static void  DoCommandMsg __P((struct msg *));
  51 #if defined(_SEQUENT_) && !defined(NAMEDPIPE)
  52 # define connect sconnect       /* _SEQUENT_ has braindamaged connect */
  53 static int   sconnect __P((int, struct sockaddr *, int));
  54 #endif
  55 static void  FinishAttach __P((struct msg *));
  56 static void  FinishDetach __P((struct msg *));
  57 static void  AskPassword __P((struct msg *));
  58
  59
  60 extern char *RcFileName, *extra_incap, *extra_outcap;
  61 extern int ServerSocket, real_uid, real_gid, eff_uid, eff_gid;
  62 extern int dflag, iflag, rflag, lsflag, quietflag, wipeflag, xflag;
  63 extern char *attach_tty, *LoginName, HostName[];
  64 extern struct display *display, *displays;
  65 extern struct win *fore, *wtab[], *console_window, *windows;
  66 extern struct layer *flayer;
  67 extern struct layout *layout_attach, *layout_last, layout_last_marker;
  68 extern struct NewWindow nwin_undef;
  69 #ifdef MULTIUSER
  70 extern char *multi;
  71 #endif
  72
  73 extern char *getenv();
  74
  75 extern char SockPath[];
  76 extern struct event serv_read;
  77 extern char *rc_name;
  78 extern struct comm comms[];
  79
  80 #ifdef MULTIUSER
  81 # define SOCKMODE (S_IWRITE | S_IREAD | (displays ? S_IEXEC : 0) | (multi ? 1 : 0))
  82 #else
  83 # define SOCKMODE (S_IWRITE | S_IREAD | (displays ? S_IEXEC : 0))
  84 #endif
  85
  86
  87 /*
  88  *  Socket directory manager
  89  *
  90  *  fdp: pointer to store the first good socket.
  91  *  nfoundp: pointer to store the number of sockets found matching.
  92  *  notherp: pointer to store the number of sockets not matching.
  93  *  match: string to match socket name.
  94  *
  95  *  The socket directory must be in SockPath!
  96  *  The global variables LoginName, multi, rflag, xflag, dflag,
  97  *  quietflag, SockPath are used.
  98  *
  99  *  The first good socket is stored in fdp and its name is
 100  *  appended to SockPath.
 101  *  If none exists or fdp is NULL SockPath is not changed.
 102  *
 103  *  Returns: number of good sockets.
 104  *
 105  */
 106
 107 int
 108 FindSocket(fdp, nfoundp, notherp, match)
 109 int *fdp;
 110 int *nfoundp, *notherp;
 111 char *match;
 112 {
 113   DIR *dirp;
 114   struct dirent *dp;
 115   struct stat st;
 116   int mode;
 117   int sdirlen;
 118   int  matchlen = 0;
 119   char *name, *n;
 120   int firsts = -1, sockfd;
 121   char *firstn = NULL;
 122   int nfound = 0, ngood = 0, ndead = 0, nwipe = 0, npriv = 0;
 123   int nperfect = 0;
 124   struct sent
 125     {
 126       struct sent *next;
 127       int mode;
 128       char *name;
 129     } *slist, **slisttail, *sent, *nsent;
 130
 131   if (match)
 132     {
 133       matchlen = strlen(match);
 134 #ifdef NAME_MAX
 135       if (matchlen > NAME_MAX)
 136         matchlen = NAME_MAX;
 137 #endif
 138     }
 139
 140   /*
 141    * SockPath contains the socket directory.
 142    * At the end of FindSocket the socket name will be appended to it.
 143    * Thus FindSocket() can only be called once!
 144    */
 145   sdirlen = strlen(SockPath);
 146
 147 #ifdef USE_SETEUID
 148   xseteuid(real_uid);
 149   xsetegid(real_gid);
 150 #endif
 151
 152   if ((dirp = opendir(SockPath)) == 0)
 153     Panic(errno, "Cannot opendir %s", SockPath);
 154
 155   slist = 0;
 156   slisttail = &slist;
 157   while ((dp = readdir(dirp)))
 158     {
 159       int cmatch = 0;
 160       name = dp->d_name;
 161       debug1("- %s\n",  name);
 162       if (*name == 0 || *name == '.' || strlen(name) > 2*MAXSTR)
 163         continue;
 164       if (matchlen)
 165         {
 166           n = name;
 167           /* if we don't want to match digits. Skip them */
 168           if ((*match <= '0' || *match > '9') && (*n > '0' && *n <= '9'))
 169             {
 170               while (*n >= '0' && *n <= '9')
 171                 n++;
 172               if (*n == '.')
 173                 n++;
 174             }
 175           /* the tty prefix is optional */
 176           if (strncmp(match, "tty", 3) && strncmp(n, "tty", 3) == 0)
 177             n += 3;
 178           if (strncmp(match, n, matchlen))
 179             continue;
 180           cmatch = (*(n + matchlen) == 0);
 181           debug1("  -> matched %s\n", match);
 182         }
 183       sprintf(SockPath + sdirlen, "/%s", name);
 184
 185       debug1("stat %s\n", SockPath);
 186       errno = 0;
 187       debug2("uid = %d, gid = %d\n", getuid(), getgid());
 188       debug2("euid = %d, egid = %d\n", geteuid(), getegid());
 189       if (stat(SockPath, &st))
 190         {
 191           debug1("errno = %d\n", errno);
 192           continue;
 193         }
 194
 195 #ifndef SOCK_NOT_IN_FS
 196 # ifdef NAMEDPIPE
 197 #  ifdef S_ISFIFO
 198       debug("S_ISFIFO?\n");
 199       if (!S_ISFIFO(st.st_mode))
 200         continue;
 201 #  endif
 202 # else
 203 #  ifdef S_ISSOCK
 204       debug("S_ISSOCK?\n");
 205       if (!S_ISSOCK(st.st_mode))
 206         continue;
 207 #  endif
 208 # endif
 209 #endif
 210
 211       debug2("st.st_uid = %d, real_uid = %d\n", st.st_uid, real_uid);
 212       if ((int)st.st_uid != real_uid)
 213         continue;
 214       mode = (int)st.st_mode & 0777;
 215       debug1("  has mode 0%03o\n", mode);
 216 #ifdef MULTIUSER
 217       if (multi && ((mode & 0677) != 0601))
 218         {
 219           debug("  is not a MULTI-USER session");
 220           if (strcmp(multi, LoginName))
 221             {
 222               debug(" and we are in a foreign directory.\n");
 223               mode = -4;
 224             }
 225           else
 226             {
 227               debug(", but it is our own session.\n");
 228             }
 229         }
 230 #endif
 231       debug("  store it.\n");
 232       if ((sent = (struct sent *)malloc(sizeof(struct sent))) == 0)
 233         continue;
 234       sent->next = 0;
 235       sent->name = SaveStr(name);
 236       sent->mode = mode;
 237       *slisttail = sent;
 238       slisttail = &sent->next;
 239       nfound++;
 240       sockfd = MakeClientSocket(0);
 241 #ifdef USE_SETEUID
 242       /* MakeClientSocket sets ids back to eff */
 243       xseteuid(real_uid);
 244       xsetegid(real_gid);
 245 #endif
 246       if (sockfd == -1)
 247         {
 248           debug2("  MakeClientSocket failed, unreachable? %d %d\n",
 249                  matchlen, wipeflag);
 250           sent->mode = -3;
 251 #ifndef SOCKDIR_IS_LOCAL_TO_HOST
 252           /* Unreachable - it is dead if we detect that it's local
 253            * or we specified a match
 254            */
 255           n = name + strlen(name) - 1;
 256           while (n != name && *n != '.')
 257             n--;
 258           if (matchlen == 0  && !(*n == '.' && n[1] && strncmp(HostName, n + 1, strlen(n + 1)) == 0))
 259             {
 260               npriv++;          /* a good socket that was not for us */
 261               continue;
 262             }
 263 #endif
 264           ndead++;
 265           sent->mode = -1;
 266           if (wipeflag)
 267             {
 268               if (unlink(SockPath) == 0)
 269                 {
 270                   sent->mode = -2;
 271                   nwipe++;
 272                 }
 273             }
 274           continue;
 275         }
 276
 277       mode &= 0776;
 278       /* Shall we connect ? */
 279       debug2("  connecting: mode=%03o, rflag=%d, ", mode, rflag);
 280       debug2("xflag=%d, dflag=%d ?\n", xflag, dflag);
 281
 282       /*
 283        * mode 600: socket is detached.
 284        * mode 700: socket is attached.
 285        * xflag implies rflag here.
 286        *
 287        * fail, when socket mode mode is not 600 or 700
 288        * fail, when we want to detach w/o reattach, but it already is detached.
 289        * fail, when we only want to attach, but mode 700 and not xflag.
 290        * fail, if none of dflag, rflag, xflag is set.
 291        */
 292       if ((mode != 0700 && mode != 0600) ||
 293           (dflag && !rflag && !xflag && mode == 0600) ||
 294           (!dflag && rflag && mode == 0700 && !xflag) ||
 295           (!dflag && !rflag && !xflag))
 296         {
 297           close(sockfd);
 298           debug("  no!\n");
 299           npriv++;              /* a good socket that was not for us */
 300           continue;
 301         }
 302       ngood++;
 303       if (cmatch)
 304         nperfect++;
 305       if (fdp && (firsts == -1 || (cmatch && nperfect == 1)))
 306         {
 307           if (firsts != -1)
 308             close(firsts);
 309           firsts = sockfd;
 310           firstn = sent->name;
 311           debug("  taken.\n");
 312         }
 313       else
 314         {
 315           debug("  discarded.\n");
 316           close(sockfd);
 317         }
 318     }
 319   (void)closedir(dirp);
 320   if (!lsflag && nperfect == 1)
 321     ngood = nperfect;
 322   if (nfound && (lsflag || ngood != 1) && !quietflag)
 323     {
 324       switch(ngood)
 325         {
 326         case 0:
 327           Msg(0, nfound > 1 ? "There are screens on:" : "There is a screen on:");
 328           break;
 329         case 1:
 330           Msg(0, nfound > 1 ? "There are several screens on:" : "There is a suitable screen on:");
 331           break;
 332         default:
 333           Msg(0, "There are several suitable screens on:");
 334           break;
 335         }
 336       for (sent = slist; sent; sent = sent->next)
 337         {
 338           switch (sent->mode)
 339             {
 340             case 0700:
 341               printf("\t%s\t(Attached)\n", sent->name);
 342               break;
 343             case 0600:
 344               printf("\t%s\t(Detached)\n", sent->name);
 345               break;
 346 #ifdef MULTIUSER
 347             case 0701:
 348               printf("\t%s\t(Multi, attached)\n", sent->name);
 349               break;
 350             case 0601:
 351               printf("\t%s\t(Multi, detached)\n", sent->name);
 352               break;
 353 #endif
 354             case -1:
 355               /* No trigraphs here! */
 356               printf("\t%s\t(Dead ?%c?)\n", sent->name, '?');
 357               break;
 358             case -2:
 359               printf("\t%s\t(Removed)\n", sent->name);
 360               break;
 361             case -3:
 362               printf("\t%s\t(Remote or dead)\n", sent->name);
 363               break;
 364             case -4:
 365               printf("\t%s\t(Private)\n", sent->name);
 366               break;
 367             }
 368         }
 369     }
 370   if (ndead && !quietflag)
 371     {
 372       char *m = "Remove dead screens with 'screen -wipe'.";
 373       if (wipeflag)
 374         Msg(0, "%d socket%s wiped out.", nwipe, nwipe > 1 ? "s" : "");
 375       else
 376         Msg(0, m, ndead > 1 ? "s" : "", ndead > 1 ? "" : "es"); /* other args for nethack */
 377     }
 378   if (firsts != -1)
 379     {
 380       sprintf(SockPath + sdirlen, "/%s", firstn);
 381       *fdp = firsts;
 382     }
 383   else
 384     SockPath[sdirlen] = 0;
 385   for (sent = slist; sent; sent = nsent)
 386     {
 387       nsent = sent->next;
 388       free(sent->name);
 389       free((char *)sent);
 390     }
 391 #ifdef USE_SETEUID
 392   xseteuid(eff_uid);
 393   xsetegid(eff_gid);
 394 #endif
 395   if (notherp)
 396     *notherp = npriv;
 397   if (nfoundp)
 398     *nfoundp = nfound - nwipe;
 399   return ngood;
 400 }
 401
 402
 403 /*
 404 **
 405 **        Socket/pipe create routines
 406 **
 407 */
 408
 409 #ifdef NAMEDPIPE
 410
 411 int
 412 MakeServerSocket()
 413 {
 414   register int s;
 415   struct stat st;
 416
 417 # ifdef USE_SETEUID
 418   xseteuid(real_uid);
 419   xsetegid(real_gid);
 420 # endif
 421   if ((s = open(SockPath, O_WRONLY | O_NONBLOCK)) >= 0)
 422     {
 423       debug("huii, my fifo already exists??\n");
 424       if (quietflag)
 425         {
 426           Kill(D_userpid, SIG_BYE);
 427           eexit(11);
 428         }
 429       Msg(0, "There is already a screen running on %s.", Filename(SockPath));
 430       if (stat(SockPath, &st) == -1)
 431         Panic(errno, "stat");
 432       if ((int)st.st_uid != real_uid)
 433         Panic(0, "Unfortunatelly you are not its owner.");
 434       if ((st.st_mode & 0700) == 0600)
 435         Panic(0, "To resume it, use \"screen -r\"");
 436       else
 437         Panic(0, "It is not detached.");
 438       /* NOTREACHED */
 439     }
 440 # ifdef USE_SETEUID
 441   (void) unlink(SockPath);
 442   if (mkfifo(SockPath, SOCKMODE))
 443     Panic(0, "mkfifo %s failed", SockPath);
 444 #  ifdef BROKEN_PIPE
 445   if ((s = open(SockPath, O_RDWR | O_NONBLOCK, 0)) < 0)
 446 #  else
 447   if ((s = open(SockPath, O_RDONLY | O_NONBLOCK, 0)) < 0)
 448 #  endif
 449     Panic(errno, "open fifo %s", SockPath);
 450   xseteuid(eff_uid);
 451   xsetegid(eff_gid);
 452   return s;
 453 # else /* !USE_SETEUID */
 454   if (UserContext() > 0)
 455     {
 456       (void) unlink(SockPath);
 457       UserReturn(mkfifo(SockPath, SOCKMODE));
 458     }
 459   if (UserStatus())
 460     Panic(0, "mkfifo %s failed", SockPath);
 461 #  ifdef BROKEN_PIPE
 462   if ((s = secopen(SockPath, O_RDWR | O_NONBLOCK, 0)) < 0)
 463 #  else
 464   if ((s = secopen(SockPath, O_RDONLY | O_NONBLOCK, 0)) < 0)
 465 #  endif
 466     Panic(errno, "open fifo %s", SockPath);
 467   return s;
 468 # endif /* !USE_SETEUID */
 469 }
 470
 471
 472 int
 473 MakeClientSocket(err)
 474 int err;
 475 {
 476   register int s = 0;
 477
 478   if ((s = secopen(SockPath, O_WRONLY | O_NONBLOCK, 0)) >= 0)
 479     {
 480       (void) fcntl(s, F_SETFL, 0);
 481       return s;
 482     }
 483   if (err)
 484     Msg(errno, "%s", SockPath);
 485   debug2("MakeClientSocket() open %s failed (%d)\n", SockPath, errno);
 486   return -1;
 487 }
 488
 489
 490 #else   /* NAMEDPIPE */
 491
 492
 493 int
 494 MakeServerSocket()
 495 {
 496   register int s;
 497   struct sockaddr_un a;
 498   struct stat st;
 499
 500   if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
 501     Panic(errno, "socket");
 502   a.sun_family = AF_UNIX;
 503   strncpy(a.sun_path, SockPath, sizeof(a.sun_path));
 504   a.sun_path[sizeof(a.sun_path) - 1] = 0;
 505 # ifdef USE_SETEUID
 506   xseteuid(real_uid);
 507   xsetegid(real_gid);
 508 # endif
 509   if (connect(s, (struct sockaddr *) &a, strlen(SockPath) + 2) != -1)
 510     {
 511       debug("oooooh! socket already is alive!\n");
 512       if (quietflag)
 513         {
 514           Kill(D_userpid, SIG_BYE);
 515           /*
 516            * oh, well. nobody receives that return code. papa
 517            * dies by signal.
 518            */
 519           eexit(11);
 520         }
 521       Msg(0, "There is already a screen running on %s.", Filename(SockPath));
 522       if (stat(SockPath, &st) == -1)
 523         Panic(errno, "stat");
 524       if (st.st_uid != real_uid)
 525         Panic(0, "Unfortunatelly you are not its owner.");
 526       if ((st.st_mode & 0700) == 0600)
 527         Panic(0, "To resume it, use \"screen -r\"");
 528       else
 529         Panic(0, "It is not detached.");
 530       /* NOTREACHED */
 531     }
 532 #if defined(m88k) || defined(sysV68)
 533   close(s);     /* we get bind: Invalid argument if this is not done */
 534   if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
 535     Panic(errno, "reopen socket");
 536 #endif
 537   (void) unlink(SockPath);
 538   if (bind(s, (struct sockaddr *) & a, strlen(SockPath) + 2) == -1)
 539     Panic(errno, "bind (%s)", SockPath);
 540 #ifdef SOCK_NOT_IN_FS
 541     {
 542       int f;
 543       if ((f = secopen(SockPath, O_RDWR | O_CREAT, SOCKMODE)) < 0)
 544         Panic(errno, "shadow socket open");
 545       close(f);
 546     }
 547 #else
 548   chmod(SockPath, SOCKMODE);
 549 # ifndef USE_SETEUID
 550   chown(SockPath, real_uid, real_gid);
 551 # endif
 552 #endif /* SOCK_NOT_IN_FS */
 553   if (listen(s, 5) == -1)
 554     Panic(errno, "listen");
 555 # ifdef F_SETOWN
 556   fcntl(s, F_SETOWN, getpid());
 557   debug1("Serversocket owned by %d\n", fcntl(s, F_GETOWN, 0));
 558 # endif /* F_SETOWN */
 559 # ifdef USE_SETEUID
 560   xseteuid(eff_uid);
 561   xsetegid(eff_gid);
 562 # endif
 563   return s;
 564 }
 565
 566 int
 567 MakeClientSocket(err)
 568 int err;
 569 {
 570   register int s;
 571   struct sockaddr_un a;
 572
 573   if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
 574     Panic(errno, "socket");
 575   a.sun_family = AF_UNIX;
 576   strncpy(a.sun_path, SockPath, sizeof(a.sun_path));
 577   a.sun_path[sizeof(a.sun_path) - 1] = 0;
 578 # ifdef USE_SETEUID
 579   xseteuid(real_uid);
 580   xsetegid(real_gid);
 581 # else
 582   if (access(SockPath, W_OK))
 583     {
 584       if (err)
 585         Msg(errno, "%s", SockPath);
 586       debug2("MakeClientSocket: access(%s): %d.\n", SockPath, errno);
 587       close(s);
 588       return -1;
 589     }
 590 # endif
 591   if (connect(s, (struct sockaddr *) &a, strlen(SockPath) + 2) == -1)
 592     {
 593       if (err)
 594         Msg(errno, "%s: connect", SockPath);
 595       debug("MakeClientSocket: connect failed.\n");
 596       close(s);
 597       s = -1;
 598     }
 599 # ifdef USE_SETEUID
 600   xseteuid(eff_uid);
 601   xsetegid(eff_gid);
 602 # endif
 603   return s;
 604 }
 605 #endif /* NAMEDPIPE */
 606
 607
 608 /*
 609 **
 610 **       Message send and receive routines
 611 **
 612 */
 613
 614 void
 615 SendCreateMsg(sty, nwin)
 616 char *sty;
 617 struct NewWindow *nwin;
 618 {
 619   int s;
 620   struct msg m;
 621   register char *p;
 622   register int len, n;
 623   char **av = nwin->args;
 624
 625 #ifdef NAME_MAX
 626   if (strlen(sty) > NAME_MAX)
 627     sty[NAME_MAX] = 0;
 628 #endif
 629   if (strlen(sty) > 2 * MAXSTR - 1)
 630     sty[2 * MAXSTR - 1] = 0;
 631   sprintf(SockPath + strlen(SockPath), "/%s", sty);
 632   if ((s = MakeClientSocket(1)) == -1)
 633     exit(1);
 634   debug1("SendCreateMsg() to '%s'\n", SockPath);
 635   bzero((char *)&m, sizeof(m));
 636   m.type = MSG_CREATE;
 637   strncpy(m.m_tty, attach_tty, sizeof(m.m_tty) - 1);
 638   m.m_tty[sizeof(m.m_tty) - 1] = 0;
 639   p = m.m.create.line;
 640   n = 0;
 641   if (nwin->args != nwin_undef.args)
 642     for (av = nwin->args; *av && n < MAXARGS - 1; ++av, ++n)
 643       {
 644         len = strlen(*av) + 1;
 645         if (p + len >= m.m.create.line + sizeof(m.m.create.line) - 1)
 646           break;
 647         strcpy(p, *av);
 648         p += len;
 649       }
 650   if (nwin->aka != nwin_undef.aka && p + strlen(nwin->aka) + 1 < m.m.create.line + sizeof(m.m.create.line))
 651     strcpy(p, nwin->aka);
 652   else
 653     *p = '\0';
 654   m.m.create.nargs = n;
 655   m.m.create.aflag = nwin->aflag;
 656   m.m.create.flowflag = nwin->flowflag;
 657   m.m.create.lflag = nwin->lflag;
 658   m.m.create.hheight = nwin->histheight;
 659   if (getcwd(m.m.create.dir, sizeof(m.m.create.dir)) == 0)
 660     {
 661       Msg(errno, "getcwd");
 662       return;
 663     }
 664   if (nwin->term != nwin_undef.term)
 665     strncpy(m.m.create.screenterm, nwin->term, 19);
 666   m.m.create.screenterm[19] = '\0';
 667   m.protocol_revision = MSG_REVISION;
 668   debug1("SendCreateMsg writing '%s'\n", m.m.create.line);
 669   if (write(s, (char *) &m, sizeof m) != sizeof m)
 670     Msg(errno, "write");
 671   close(s);
 672 }
 673
 674 int
 675 SendErrorMsg(tty, buf)
 676 char *tty, *buf;
 677 {
 678   int s;
 679   struct msg m;
 680
 681   strncpy(m.m.message, buf, sizeof(m.m.message) - 1);
 682   m.m.message[sizeof(m.m.message) - 1] = 0;
 683   s = MakeClientSocket(0);
 684   if (s < 0)
 685     return -1;
 686   m.type = MSG_ERROR;
 687   strncpy(m.m_tty, tty, sizeof(m.m_tty) - 1);
 688   m.m_tty[sizeof(m.m_tty) - 1] = 0;
 689   m.protocol_revision = MSG_REVISION;
 690   debug1("SendErrorMsg(): writing to '%s'\n", SockPath);
 691   (void) write(s, (char *) &m, sizeof m);
 692   close(s);
 693   return 0;
 694 }
 695
 696 static void
 697 ExecCreate(mp)
 698 struct msg *mp;
 699 {
 700   struct NewWindow nwin;
 701   char *args[MAXARGS];
 702   register int n;
 703   register char **pp = args, *p = mp->m.create.line;
 704
 705   nwin = nwin_undef;
 706   n = mp->m.create.nargs;
 707   if (n > MAXARGS - 1)
 708     n = MAXARGS - 1;
 709   /* ugly hack alert... should be done by the frontend! */
 710   if (n)
 711     {
 712       int l, num;
 713       char buf[20];
 714
 715       l = strlen(p);
 716       if (IsNumColon(p, 10, buf, sizeof(buf)))
 717         {
 718           if (*buf)
 719             nwin.aka = buf;
 720           num = atoi(p);
 721           if (num < 0 || num > MAXWIN - 1)
 722             num = 0;
 723           nwin.StartAt = num;
 724           p += l + 1;
 725           n--;
 726         }
 727     }
 728   for (; n > 0; n--)
 729     {
 730       *pp++ = p;
 731       p += strlen(p) + 1;
 732     }
 733   *pp = 0;
 734   if (*p)
 735     nwin.aka = p;
 736   if (*args)
 737     nwin.args = args;
 738   nwin.aflag = mp->m.create.aflag;
 739   nwin.flowflag = mp->m.create.flowflag;
 740   if (*mp->m.create.dir)
 741     nwin.dir = mp->m.create.dir;
 742   nwin.lflag = mp->m.create.lflag;
 743   nwin.histheight = mp->m.create.hheight;
 744   if (*mp->m.create.screenterm)
 745     nwin.term =  mp->m.create.screenterm;
 746   MakeWindow(&nwin);
 747 }
 748
 749 static int
 750 CheckPid(pid)
 751 int pid;
 752 {
 753   debug1("Checking pid %d\n", pid);
 754   if (pid < 2)
 755     return -1;
 756   if (eff_uid == real_uid)
 757     return kill(pid, 0);
 758   if (UserContext() > 0)
 759     UserReturn(kill(pid, 0));
 760   return UserStatus();
 761 }
 762
 763 #ifdef hpux
 764 /*
 765  * From: "F. K. Bruner" <napalm@ugcs.caltech.edu>
 766  * From: "Dan Egnor" <egnor@oracorp.com> Tue Aug 10 06:56:45 1993
 767  * The problem is that under HPUX (and possibly other systems too) there are
 768  * two equivalent device files for each pty/tty device:
 769  * /dev/ttyxx == /dev/pty/ttyxx
 770  * /dev/ptyxx == /dev/ptym/ptyxx
 771  * I didn't look into the exact specifics, but I've run across this problem
 772  * before: Even if you open /dev/ttyxx as fds 0 1 & 2 for a process, if that
 773  * process calls the system to determine its tty, it'll get /dev/pty/ttyxx.
 774  *
 775  * Earlier versions seemed to work -- wonder what they did.
 776  */
 777 static int
 778 ttycmp(s1, s2)
 779 char *s1, *s2;
 780 {
 781   if (strlen(s1) > 5) s1 += strlen(s1) - 5;
 782   if (strlen(s2) > 5) s2 += strlen(s2) - 5;
 783   return strcmp(s1, s2);
 784 }
 785 # define TTYCMP(a, b) ttycmp(a, b)
 786 #else
 787 # define TTYCMP(a, b) strcmp(a, b)
 788 #endif
 789
 790 static int
 791 CreateTempDisplay(m, recvfd, wi)
 792 struct msg *m;
 793 int recvfd;
 794 struct win *wi;
 795 {
 796   int pid;
 797   int attach;
 798   char *user;
 799   int i;
 800   struct mode Mode;
 801   struct display *olddisplays = displays;
 802
 803   switch (m->type)
 804     {
 805       case MSG_ATTACH:
 806         pid = m->m.attach.apid;
 807         user = m->m.attach.auser;
 808         attach = 1;
 809         break;
 810 #ifdef REMOTE_DETACH
 811       case MSG_DETACH:
 812 # ifdef POW_DETACH
 813       case MSG_POW_DETACH:
 814 # endif                         /* POW_DETACH */
 815         pid = m->m.detach.dpid;
 816         user = m->m.detach.duser;
 817         attach = 0;
 818         break;
 819 #endif
 820       default:
 821         return -1;
 822     }
 823
 824   if (CheckPid(pid))
 825     {
 826       Msg(0, "Attach attempt with bad pid(%d)!", pid);
 827       return -1;
 828     }
 829   if (recvfd != -1)
 830     {
 831       char *myttyname;
 832       i = recvfd;
 833       recvfd = -1;
 834       myttyname = ttyname(i);
 835       if (myttyname == 0 || strcmp(myttyname, m->m_tty))
 836         {
 837           Msg(errno, "Attach: passed fd does not match tty: %s - %s!", m->m_tty, myttyname ? myttyname : "NULL");
 838           close(i);
 839           Kill(pid, SIG_BYE);
 840           return -1;
 841         }
 842     }
 843   else if ((i = secopen(m->m_tty, O_RDWR | O_NONBLOCK, 0)) < 0)
 844     {
 845       Msg(errno, "Attach: Could not open %s!", m->m_tty);
 846       Kill(pid, SIG_BYE);
 847       return -1;
 848     }
 849 #ifdef MULTIUSER
 850   if (attach)
 851     Kill(pid, SIGCONT);
 852 #endif
 853
 854 #if defined(ultrix) || defined(pyr) || defined(NeXT)
 855   brktty(i);    /* for some strange reason this must be done */
 856 #endif
 857
 858   if (attach)
 859     {
 860       if (display || wi)
 861         {
 862           write(i, "Attaching from inside of screen?\n", 33);
 863           close(i);
 864           Kill(pid, SIG_BYE);
 865           Msg(0, "Attach msg ignored: coming from inside.");
 866           return -1;
 867         }
 868
 869 #ifdef MULTIUSER
 870       if (strcmp(user, LoginName))
 871         if (*FindUserPtr(user) == 0)
 872           {
 873               write(i, "Access to session denied.\n", 26);
 874               close(i);
 875               Kill(pid, SIG_BYE);
 876               Msg(0, "Attach: access denied for user %s.", user);
 877               return -1;
 878           }
 879 #endif
 880
 881       debug2("RecMsg: apid %d is o.k. and we just opened '%s'\n", pid, m->m_tty);
 882 #ifndef MULTI
 883       if (displays)
 884         {
 885           write(i, "Screen session in use.\n", 23);
 886           close(i);
 887           Kill(pid, SIG_BYE);
 888           return -1;
 889         }
 890 #endif
 891     }
 892
 893   /* create new display */
 894   GetTTY(i, &Mode);
 895   if (MakeDisplay(user, m->m_tty, attach ? m->m.attach.envterm : "", i, pid, &Mode) == 0)
 896     {
 897       write(i, "Could not make display.\n", 24);
 898       close(i);
 899       Msg(0, "Attach: could not make display for user %s", user);
 900       Kill(pid, SIG_BYE);
 901       return -1;
 902     }
 903 #ifdef ENCODINGS
 904   if (attach)
 905     {
 906 # ifdef UTF8
 907       D_encoding = m->m.attach.encoding == 1 ? UTF8 : m->m.attach.encoding ? m->m.attach.encoding - 1 : 0;
 908 # else
 909       D_encoding = m->m.attach.encoding ? m->m.attach.encoding - 1 : 0;
 910 # endif
 911       if (D_encoding < 0 || !EncodingName(D_encoding))
 912         D_encoding = 0;
 913 #endif
 914     }
 915
 916   if (iflag && olddisplays)
 917     {
 918       iflag = 0;
 919 #if defined(TERMIO) || defined(POSIX)
 920       olddisplays->d_NewMode.tio.c_cc[VINTR] = VDISABLE;
 921       olddisplays->d_NewMode.tio.c_lflag &= ~ISIG;
 922 #else /* TERMIO || POSIX */
 923       olddisplays->d_NewMode.m_tchars.t_intrc = -1;
 924 #endif /* TERMIO || POSIX */
 925       SetTTY(olddisplays->d_userfd, &olddisplays->d_NewMode);
 926     }
 927   SetMode(&D_OldMode, &D_NewMode, D_flow, iflag);
 928   SetTTY(D_userfd, &D_NewMode);
 929   if (fcntl(D_userfd, F_SETFL, FNBLOCK))
 930     Msg(errno, "Warning: NBLOCK fcntl failed");
 931   return 0;
 932 }
 933
 934 void
 935 ReceiveMsg()
 936 {
 937   int left, len;
 938   static struct msg m;
 939   char *p;
 940   int ns = ServerSocket;
 941   struct win *wi;
 942   int recvfd = -1;
 943   struct acluser *user;
 944
 945 #ifdef NAMEDPIPE
 946   debug("Ha, there was someone knocking on my fifo??\n");
 947   if (fcntl(ServerSocket, F_SETFL, 0) == -1)
 948     Panic(errno, "BLOCK fcntl");
 949   p = (char *) &m;
 950   left = sizeof(m);
 951 #else
 952   struct sockaddr_un a;
 953   struct msghdr msg;
 954   struct iovec iov;
 955   char control[1024];
 956
 957   len = sizeof(a);
 958   debug("Ha, there was someone knocking on my socket??\n");
 959   if ((ns = accept(ns, (struct sockaddr *) &a, (void *)&len)) < 0)
 960     {
 961       Msg(errno, "accept");
 962       return;
 963     }
 964
 965   p = (char *) &m;
 966   left = sizeof(m);
 967   bzero(&msg, sizeof(msg));
 968   iov.iov_base = &m;
 969   iov.iov_len = left;
 970   msg.msg_iov = &iov;
 971   msg.msg_iovlen  = 1;
 972   msg.msg_controllen = sizeof(control);
 973   msg.msg_control = &control;
 974   while (left > 0)
 975     {
 976       len = recvmsg(ns, &msg, 0);
 977       if (len < 0 && errno == EINTR)
 978         continue;
 979       if (len < 0)
 980         {
 981           close(ns);
 982           Msg(errno, "read");
 983           return;
 984         }
 985       if (msg.msg_controllen)
 986         {
 987           struct cmsghdr  *cmsg;
 988           for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg))
 989             {
 990               int cl;
 991               char *cp;
 992               if (cmsg->cmsg_level != SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS)
 993                 continue;
 994               cp = (char *)CMSG_DATA(cmsg);
 995               cl = cmsg->cmsg_len;
 996               while(cl >= CMSG_LEN(sizeof(int)))
 997                 {
 998                   int passedfd;
 999                   bcopy(cp, &passedfd, sizeof(int));
1000                   if (recvfd >= 0 && passedfd != recvfd)
1001                     close(recvfd);
1002                   recvfd = passedfd;
1003                   cl -= CMSG_LEN(sizeof(int));
1004                 }
1005             }
1006         }
1007       p += len;
1008       left -= len;
1009       break;
1010     }
1011
1012 #endif
1013
1014   while (left > 0)
1015     {
1016       len = read(ns, p, left);
1017       if (len < 0 && errno == EINTR)
1018         continue;
1019       if (len <= 0)
1020         break;
1021       p += len;
1022       left -= len;
1023     }
1024
1025 #ifdef NAMEDPIPE
1026 # ifndef BROKEN_PIPE
1027   /* Reopen pipe to prevent EOFs at the select() call */
1028   close(ServerSocket);
1029   if ((ServerSocket = secopen(SockPath, O_RDONLY | O_NONBLOCK, 0)) < 0)
1030     Panic(errno, "reopen fifo %s", SockPath);
1031   evdeq(&serv_read);
1032   serv_read.fd = ServerSocket;
1033   evenq(&serv_read);
1034 # endif
1035 #else
1036   close(ns);
1037 #endif
1038
1039   if (len < 0)
1040     {
1041       Msg(errno, "read");
1042       if (recvfd != -1)
1043         close(recvfd);
1044       return;
1045     }
1046   if (left > 0)
1047     {
1048       if (left != sizeof(m))
1049         Msg(0, "Message %d of %d bytes too small", left, (int)sizeof(m));
1050       else
1051         debug("No data on socket.\n");
1052       return;
1053     }
1054   if (m.protocol_revision != MSG_REVISION)
1055     {
1056       if (recvfd != -1)
1057         close(recvfd);
1058       Msg(0, "Invalid message (magic 0x%08x).", m.protocol_revision);
1059       return;
1060     }
1061
1062   debug2("*** RecMsg: type %d tty %s\n", m.type, m.m_tty);
1063   if (m.type != MSG_ATTACH && recvfd != -1)
1064     {
1065       close(recvfd);
1066       recvfd = -1;
1067     }
1068
1069   for (display = displays; display; display = display->d_next)
1070     if (TTYCMP(D_usertty, m.m_tty) == 0)
1071       break;
1072   debug2("display: %s display %sfound\n", m.m_tty, display ? "" : "not ");
1073   wi = 0;
1074   if (!display)
1075     {
1076       for (wi = windows; wi; wi = wi->w_next)
1077         if (!TTYCMP(m.m_tty, wi->w_tty))
1078           {
1079             /* XXX: hmmm, rework this? */
1080             display = wi->w_layer.l_cvlist ? wi->w_layer.l_cvlist->c_display : 0;
1081             debug2("but window %s %sfound.\n", m.m_tty, display ? "" :
1082                    "(backfacing)");
1083             break;
1084           }
1085     }
1086
1087   /* Remove the status to prevent garbage on the screen */
1088   if (display && D_status)
1089     RemoveStatus();
1090
1091   if (display && !D_tcinited && m.type != MSG_HANGUP)
1092     {
1093       if (recvfd != -1)
1094         close(recvfd);
1095       return;           /* ignore messages for bad displays */
1096     }
1097
1098   switch (m.type)
1099     {
1100     case MSG_WINCH:
1101       if (display)
1102         CheckScreenSize(1); /* Change fore */
1103       break;
1104     case MSG_CREATE:
1105       /*
1106        * the window that issued the create message need not be an active
1107        * window. Then we create the window without having a display.
1108        * Resulting in another inactive window.
1109        */
1110       ExecCreate(&m);
1111       break;
1112     case MSG_CONT:
1113         if (display && D_userpid != 0 && kill(D_userpid, 0) == 0)
1114           break;                /* Intruder Alert */
1115       debug2("RecMsg: apid=%d,was %d\n", m.m.attach.apid, display ? D_userpid : 0);
1116       /* FALLTHROUGH */
1117
1118     case MSG_ATTACH:
1119       if (CreateTempDisplay(&m, recvfd, wi))
1120         break;
1121 #ifdef PASSWORD
1122       if (D_user->u_password && *D_user->u_password)
1123         AskPassword(&m);
1124       else
1125 #endif
1126         FinishAttach(&m);
1127       break;
1128     case MSG_ERROR:
1129       Msg(0, "%s", m.m.message);
1130       break;
1131     case MSG_HANGUP:
1132       if (!wi)          /* ignore hangups from inside */
1133         Hangup();
1134       break;
1135 #ifdef REMOTE_DETACH
1136     case MSG_DETACH:
1137 # ifdef POW_DETACH
1138     case MSG_POW_DETACH:
1139 # endif                         /* POW_DETACH */
1140 #ifdef PASSWORD
1141       user = *FindUserPtr(m.m.detach.duser);
1142       if (user && user->u_password && *user->u_password)
1143         {
1144           if (CreateTempDisplay(&m, recvfd, 0))
1145             break;
1146           AskPassword(&m);
1147         }
1148       else
1149 #endif /* PASSWORD */
1150         FinishDetach(&m);
1151       break;
1152 #endif
1153     case MSG_COMMAND:
1154       DoCommandMsg(&m);
1155       break;
1156     default:
1157       Msg(0, "Invalid message (type %d).", m.type);
1158     }
1159 }
1160
1161 #if defined(_SEQUENT_) && !defined(NAMEDPIPE)
1162 #undef connect
1163 /*
1164  *  sequent_ptx socket emulation must have mode 000 on the socket!
1165  */
1166 static int
1167 sconnect(s, sapp, len)
1168 int s, len;
1169 struct sockaddr *sapp;
1170 {
1171   register struct sockaddr_un *sap;
1172   struct stat st;
1173   int x;
1174
1175   sap = (struct sockaddr_un *)sapp;
1176   if (stat(sap->sun_path, &st))
1177     return -1;
1178   chmod(sap->sun_path, 0);
1179   x = connect(s, (struct sockaddr *) sap, len);
1180   chmod(sap->sun_path, st.st_mode);
1181   return x;
1182 }
1183 #endif
1184
1185
1186 /*
1187  * Set the mode bits of the socket to the current status
1188  */
1189 int
1190 chsock()
1191 {
1192   int r, euid = geteuid();
1193   if (euid != real_uid)
1194     {
1195       if (UserContext() <= 0)
1196         return UserStatus();
1197     }
1198   r = chmod(SockPath, SOCKMODE);
1199   /*
1200    * Sockets usually reside in the /tmp/ area, where sysadmin scripts
1201    * may be happy to remove old files. We manually prevent the socket
1202    * from becoming old. (chmod does not touch mtime).
1203    */
1204   (void)utimes(SockPath, NULL);
1205
1206   if (euid != real_uid)
1207     UserReturn(r);
1208   return r;
1209 }
1210
1211 /*
1212  * Try to recreate the socket/pipe
1213  */
1214 int
1215 RecoverSocket()
1216 {
1217   close(ServerSocket);
1218   if ((int)geteuid() != real_uid)
1219     {
1220       if (UserContext() > 0)
1221         UserReturn(unlink(SockPath));
1222       (void)UserStatus();
1223     }
1224   else
1225     (void) unlink(SockPath);
1226
1227   if ((ServerSocket = MakeServerSocket()) < 0)
1228     return 0;
1229   evdeq(&serv_read);
1230   serv_read.fd = ServerSocket;
1231   evenq(&serv_read);
1232   return 1;
1233 }
1234
1235
1236 static void
1237 FinishAttach(m)
1238 struct msg *m;
1239 {
1240   char *p;
1241   int pid;
1242   int noshowwin;
1243   struct win *wi;
1244
1245   ASSERT(display);
1246   pid = D_userpid;
1247
1248   if (m->m.attach.detachfirst != MSG_ATTACH)
1249     FinishDetach(m);
1250
1251 #if defined(pyr) || defined(xelos) || defined(sequent)
1252   /*
1253    * Kludge for systems with braindamaged termcap routines,
1254    * which evaluate $TERMCAP, regardless weather it describes
1255    * the correct terminal type or not.
1256    */
1257   debug("unsetenv(TERMCAP) in case of a different terminal");
1258   unsetenv("TERMCAP");
1259 #endif
1260
1261   /*
1262    * We reboot our Terminal Emulator. Forget all we knew about
1263    * the old terminal, reread the termcap entries in .screenrc
1264    * (and nothing more from .screenrc is read. Mainly because
1265    * I did not check, weather a full reinit is safe. jw)
1266    * and /etc/screenrc, and initialise anew.
1267    */
1268   if (extra_outcap)
1269     free(extra_outcap);
1270   if (extra_incap)
1271     free(extra_incap);
1272   extra_incap = extra_outcap = 0;
1273   debug2("Message says size (%dx%d)\n", m->m.attach.columns, m->m.attach.lines);
1274 #ifdef ETCSCREENRC
1275 # ifdef ALLOW_SYSSCREENRC
1276   if ((p = getenv("SYSSCREENRC")))
1277     StartRc(p, 1);
1278   else
1279 # endif
1280     StartRc(ETCSCREENRC, 1);
1281 #endif
1282   StartRc(RcFileName, 1);
1283   if (InitTermcap(m->m.attach.columns, m->m.attach.lines))
1284     {
1285       FreeDisplay();
1286       Kill(pid, SIG_BYE);
1287       return;
1288     }
1289   MakeDefaultCanvas();
1290   InitTerm(m->m.attach.adaptflag);      /* write init string on fd */
1291   if (displays->d_next == 0)
1292     (void) chsock();
1293   signal(SIGHUP, SigHup);
1294   if (m->m.attach.esc != -1 && m->m.attach.meta_esc != -1)
1295     {
1296       D_user->u_Esc = m->m.attach.esc;
1297       D_user->u_MetaEsc = m->m.attach.meta_esc;
1298     }
1299
1300 #ifdef UTMPOK
1301   /*
1302    * we set the Utmp slots again, if we were detached normally
1303    * and if we were detached by ^Z.
1304    * don't log zomies back in!
1305    */
1306   RemoveLoginSlot();
1307   if (displays->d_next == 0)
1308     for (wi = windows; wi; wi = wi->w_next)
1309       if (wi->w_ptyfd >= 0 && wi->w_slot != (slot_t) -1)
1310         SetUtmp(wi);
1311 #endif
1312
1313   D_fore = NULL;
1314   if (layout_attach)
1315     {
1316       struct layout *lay = layout_attach;
1317       if (lay == &layout_last_marker)
1318         lay = layout_last;
1319       if (lay)
1320         {
1321           LoadLayout(lay, &D_canvas);
1322           SetCanvasWindow(D_forecv, 0);
1323         }
1324     }
1325   /*
1326    * there may be a window that we remember from last detach:
1327    */
1328   debug1("D_user->u_detachwin = %d\n", D_user->u_detachwin);
1329   if (D_user->u_detachwin >= 0)
1330     fore = wtab[D_user->u_detachwin];
1331   else
1332     fore = 0;
1333
1334   /* Wayne wants us to restore the other window too. */
1335   if (D_user->u_detachotherwin >= 0)
1336     D_other = wtab[D_user->u_detachotherwin];
1337
1338   noshowwin = 0;
1339   if (*m->m.attach.preselect)
1340     {
1341       if (!strcmp(m->m.attach.preselect, "="))
1342         fore = 0;
1343       else if (!strcmp(m->m.attach.preselect, "-"))
1344         {
1345           fore = 0;
1346           noshowwin = 1;
1347         }
1348       else if (!strcmp(m->m.attach.preselect, "+"))
1349         {
1350           struct action newscreen;
1351           char *na = 0;
1352           newscreen.nr = RC_SCREEN;
1353           newscreen.args = &na;
1354           DoAction(&newscreen, -1);
1355         }
1356       else
1357         fore = FindNiceWindow(fore, m->m.attach.preselect);
1358     }
1359   else
1360     fore = FindNiceWindow(fore, 0);
1361   if (fore)
1362     SetForeWindow(fore);
1363   else if (!noshowwin)
1364     {
1365 #ifdef MULTIUSER
1366       if (!AclCheckPermCmd(D_user, ACL_EXEC, &comms[RC_WINDOWLIST]))
1367 #endif
1368         {
1369           flayer = D_forecv->c_layer;
1370           display_wlist(1, WLIST_NUM, (struct win *)0);
1371           noshowwin = 1;
1372         }
1373     }
1374   Activate(0);
1375   ResetIdle();
1376   if (!D_fore && !noshowwin)
1377     ShowWindows(-1);
1378   if (displays->d_next == 0 && console_window)
1379     {
1380       if (TtyGrabConsole(console_window->w_ptyfd, 1, "reattach") == 0)
1381         Msg(0, "console %s is on window %d", HostName, console_window->w_number);
1382     }
1383   debug("activated...\n");
1384
1385 # if defined(DEBUG) && defined(SIG_NODEBUG)
1386   if (!dfp)
1387     {
1388       sleep(1);
1389       debug1("Attacher %d must not debug, as we have debug off.\n", pid);
1390       kill(pid, SIG_NODEBUG);
1391     }
1392 # endif /* SIG_NODEBUG */
1393 }
1394
1395 static void
1396 FinishDetach(m)
1397 struct msg *m;
1398 {
1399   struct display *next, **d, *det;
1400   int pid;
1401
1402   if (m->type == MSG_ATTACH)
1403     pid = D_userpid;
1404   else
1405     pid = m->m.detach.dpid;
1406
1407   /* Remove the temporary display prompting for the password from the list */
1408   for (d = &displays; (det = *d); d = &det->d_next)
1409     {
1410       if (det->d_userpid == pid)
1411         break;
1412     }
1413   if (det)
1414     {
1415       *d = det->d_next;
1416       det->d_next = 0;
1417     }
1418
1419   for (display = displays; display; display = next)
1420     {
1421       next = display->d_next;
1422 # ifdef POW_DETACH
1423       if (m->type == MSG_POW_DETACH)
1424         Detach(D_REMOTE_POWER);
1425       else
1426 # endif                         /* POW_DETACH */
1427       if (m->type == MSG_DETACH)
1428         Detach(D_REMOTE);
1429       else if (m->type == MSG_ATTACH)
1430         {
1431 #ifdef POW_DETACH
1432           if (m->m.attach.detachfirst == MSG_POW_DETACH)
1433             Detach(D_REMOTE_POWER);
1434           else
1435 #endif
1436           if (m->m.attach.detachfirst == MSG_DETACH)
1437             Detach(D_REMOTE);
1438         }
1439     }
1440   display = displays = det;
1441   if (m->type != MSG_ATTACH)
1442     {
1443       if (display)
1444         FreeDisplay();
1445       Kill(pid, SIGCONT);
1446     }
1447 }
1448
1449 #ifdef PASSWORD
1450 static void PasswordProcessInput __P((char *, int));
1451
1452 struct pwdata {
1453   int l;
1454   char buf[20 + 1];
1455   struct msg m;
1456 };
1457
1458 static void
1459 AskPassword(m)
1460 struct msg *m;
1461 {
1462   struct pwdata *pwdata;
1463   ASSERT(display);
1464   pwdata = (struct pwdata *)malloc(sizeof(struct pwdata));
1465   if (!pwdata)
1466     Panic(0, strnomem);
1467   pwdata->l = 0;
1468   pwdata->m = *m;
1469   D_processinputdata = (char *)pwdata;
1470   D_processinput = PasswordProcessInput;
1471   AddStr("Screen password: ");
1472 }
1473
1474 static void
1475 PasswordProcessInput(ibuf, ilen)
1476 char *ibuf;
1477 int ilen;
1478 {
1479   struct pwdata *pwdata;
1480   int c, l;
1481   char *up;
1482   int pid = D_userpid;
1483
1484   pwdata = (struct pwdata *)D_processinputdata;
1485   l = pwdata->l;
1486   while (ilen-- > 0)
1487     {
1488       c = *(unsigned char *)ibuf++;
1489       if (c == '\r' || c == '\n')
1490         {
1491           up = D_user->u_password;
1492           pwdata->buf[l] = 0;
1493           if (strncmp(crypt(pwdata->buf, up), up, strlen(up)))
1494             {
1495               /* uh oh, user failed */
1496               bzero(pwdata->buf, sizeof(pwdata->buf));
1497               AddStr("\r\nPassword incorrect.\r\n");
1498               D_processinputdata = 0;   /* otherwise freed by FreeDis */
1499               FreeDisplay();
1500               Msg(0, "Illegal reattach attempt from terminal %s.", pwdata->m.m_tty);
1501               free(pwdata);
1502               Kill(pid, SIG_BYE);
1503               return;
1504             }
1505           /* great, pw matched, all is fine */
1506           bzero(pwdata->buf, sizeof(pwdata->buf));
1507           AddStr("\r\n");
1508           D_processinputdata = 0;
1509           D_processinput = ProcessInput;
1510           if (pwdata->m.type == MSG_ATTACH)
1511             FinishAttach(&pwdata->m);
1512           else
1513             FinishDetach(&pwdata->m);
1514           free(pwdata);
1515           return;
1516         }
1517       if (c == Ctrl('c'))
1518         {
1519           AddStr("\r\n");
1520           FreeDisplay();
1521           Kill(pid, SIG_BYE);
1522           return;
1523         }
1524       if (c == '\b' || c == 0177)
1525         {
1526           if (l > 0)
1527             l--;
1528           continue;
1529         }
1530       if (c == Ctrl('u'))
1531         {
1532           l = 0;
1533           continue;
1534         }
1535       if (l < (int)sizeof(pwdata->buf) - 1)
1536         pwdata->buf[l++] = c;
1537     }
1538   pwdata->l = l;
1539 }
1540 #endif
1541
1542 static void
1543 DoCommandMsg(mp)
1544 struct msg *mp;
1545 {
1546   char *args[MAXARGS];
1547   int argl[MAXARGS];
1548   int n, *lp;
1549   register char **pp = args, *p = mp->m.command.cmd;
1550   struct acluser *user;
1551 #ifdef MULTIUSER
1552   extern struct acluser *EffectiveAclUser;      /* acls.c */
1553 #else
1554   extern struct acluser *users;                 /* acls.c */
1555 #endif
1556
1557   lp = argl;
1558   n = mp->m.command.nargs;
1559   if (n > MAXARGS - 1)
1560     n = MAXARGS - 1;
1561   for (; n > 0; n--)
1562     {
1563       *pp++ = p;
1564       *lp = strlen(p);
1565       p += *lp++ + 1;
1566     }
1567   *pp = 0;
1568 #ifdef MULTIUSER
1569   user = *FindUserPtr(mp->m.attach.auser);
1570   if (user == 0)
1571     {
1572       Msg(0, "Unknown user %s tried to send a command!", mp->m.attach.auser);
1573       return;
1574     }
1575 #else
1576   user = users;
1577 #endif
1578 #ifdef PASSWORD
1579   if (user->u_password && *user->u_password)
1580     {
1581       Msg(0, "User %s has a password, cannot use -X option.", mp->m.attach.auser);
1582       return;
1583     }
1584 #endif
1585   if (!display)
1586     for (display = displays; display; display = display->d_next)
1587       if (D_user == user)
1588         break;
1589   for (fore = windows; fore; fore = fore->w_next)
1590     if (!TTYCMP(mp->m_tty, fore->w_tty))
1591       {
1592         if (!display)
1593           display = fore->w_layer.l_cvlist ? fore->w_layer.l_cvlist->c_display : 0;
1594         break;
1595       }
1596   if (!display)
1597     display = displays;         /* sigh */
1598   if (*mp->m.command.preselect)
1599     {
1600       int i = -1;
1601       if (strcmp(mp->m.command.preselect, "-"))
1602         i = WindowByNoN(mp->m.command.preselect);
1603       fore = i >= 0 ? wtab[i] : 0;
1604     }
1605   else if (!fore)
1606     {
1607       if (display && D_user == user)
1608         fore = Layer2Window(display->d_forecv->c_layer);
1609       if (!fore)
1610         {
1611           fore = user->u_detachwin >= 0 ? wtab[user->u_detachwin] : 0;
1612           fore = FindNiceWindow(fore, 0);
1613         }
1614     }
1615 #ifdef MULTIUSER
1616   EffectiveAclUser = user;
1617 #endif
1618   if (*args)
1619     {
1620       char *oldrcname = rc_name;
1621       rc_name = "-X";
1622       debug3("Running command on display %x window %x (%d)\n", display, fore, fore ? fore->w_number : -1);
1623       flayer = fore ? &fore->w_layer : 0;
1624       if (fore && fore->w_savelayer && (fore->w_blocked || fore->w_savelayer->l_cvlist == 0))
1625         flayer = fore->w_savelayer;
1626       DoCommand(args, argl);
1627       rc_name = oldrcname;
1628     }
1629 #ifdef MULTIUSER
1630   EffectiveAclUser = 0;
1631 #endif
1632 }
1633
1634 #ifndef NAMEDPIPE
1635
1636 int
1637 SendAttachMsg(s, m, fd)
1638 int s;
1639 struct msg *m;
1640 int fd;
1641 {
1642   int r;
1643   struct msghdr msg;
1644   struct iovec iov;
1645   char buf[CMSG_SPACE(sizeof(int))];
1646   struct cmsghdr *cmsg;
1647
1648   iov.iov_base = (char *)m;
1649   iov.iov_len = sizeof(*m);
1650   bzero(&msg, sizeof(msg));
1651   msg.msg_name = 0;
1652   msg.msg_namelen = 0;
1653   msg.msg_iov = &iov;
1654   msg.msg_iovlen = 1;
1655   msg.msg_control = buf;
1656   msg.msg_controllen = sizeof(buf);
1657   cmsg = CMSG_FIRSTHDR(&msg);
1658   cmsg->cmsg_level = SOL_SOCKET;
1659   cmsg->cmsg_type = SCM_RIGHTS;
1660   cmsg->cmsg_len = CMSG_LEN(sizeof(int));
1661   bcopy(&fd, CMSG_DATA(cmsg), sizeof(int));
1662   msg.msg_controllen = cmsg->cmsg_len;
1663   while(1)
1664     {
1665       r = sendmsg(s, &msg, 0);
1666       if (r == -1 && errno == EINTR)
1667         continue;
1668       if (r == -1)
1669         return -1;
1670       return 0;
1671     }
1672 }
1673
1674 #endif