[BACK]Return to tmux.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / tmux

Diff for /src/usr.bin/tmux/tmux.c between version 1.20 and 1.21

version 1.20, 2009/07/22 21:58:56 version 1.21, 2009/07/26 12:58:44
Line 57 
Line 57 
   
 __dead void      usage(void);  __dead void      usage(void);
 char            *makesockpath(const char *);  char            *makesockpath(const char *);
   int              prepare_unlock(enum hdrtype *, void **, size_t *, int);
   int              prepare_cmd(enum hdrtype *, void **, size_t *, int, char **);
   
 __dead void  __dead void
 usage(void)  usage(void)
Line 201 
Line 203 
 }  }
   
 int  int
   prepare_unlock(enum hdrtype *msg, void **buf, size_t *len, int argc)
   {
           static struct msg_unlock_data    unlockdata;
           char                            *pass;
   
           if (argc != 0) {
                   log_warnx("can't specify a command when unlocking");
                   return (-1);
           }
   
           if ((pass = getpass("Password: ")) == NULL)
                   return (-1);
   
           if (strlen(pass) >= sizeof unlockdata.pass) {
                   log_warnx("password too long");
                   return (-1);
           }
   
           strlcpy(unlockdata.pass, pass, sizeof unlockdata.pass);
           memset(pass, 0, strlen(pass));
   
           *buf = &unlockdata;
           *len = sizeof unlockdata;
   
           *msg = MSG_UNLOCK;
           return (0);
   }
   
   int
   prepare_cmd(enum hdrtype *msg, void **buf, size_t *len, int argc, char **argv)
   {
           static struct msg_command_data   cmddata;
   
           client_fill_session(&cmddata);
   
           cmddata.argc = argc;
           if (cmd_pack_argv(argc, argv, cmddata.argv, sizeof cmddata.argv) != 0) {
                   log_warnx("command too long");
                   return (-1);
           }
   
           *buf = &cmddata;
           *len = sizeof cmddata;
   
           *msg = MSG_COMMAND;
           return (0);
   }
   
   int
 main(int argc, char **argv)  main(int argc, char **argv)
 {  {
         struct client_ctx        cctx;          struct client_ctx        cctx;
         struct msg_command_data  cmddata;  
         struct buffer           *b;  
         struct cmd_list         *cmdlist;          struct cmd_list         *cmdlist;
         struct cmd              *cmd;          struct cmd              *cmd;
         struct pollfd            pfd;          struct pollfd            pfd;
           enum hdrtype             msg;
         struct hdr               hdr;          struct hdr               hdr;
         struct passwd           *pw;          struct passwd           *pw;
         char                    *s, *path, *label, *cause, *home, *pass = NULL;          struct msg_print_data    printdata;
           char                    *s, *path, *label, *home, *cause;
         char                     cwd[MAXPATHLEN];          char                     cwd[MAXPATHLEN];
           void                    *buf;
           size_t                   len;
         int                      retcode, opt, flags, unlock, cmdflags = 0;          int                      retcode, opt, flags, unlock, cmdflags = 0;
   
         unlock = flags = 0;          unlock = flags = 0;
Line 364 
Line 417 
                         exit(1);                          exit(1);
                 }                  }
         }          }
   
         if (label == NULL)          if (label == NULL)
                 label = xstrdup("default");                  label = xstrdup("default");
         if (path == NULL && (path = makesockpath(label)) == NULL) {          if (path == NULL && (path = makesockpath(label)) == NULL) {
Line 383 
Line 436 
         options_set_string(&global_s_options, "default-path", "%s", cwd);          options_set_string(&global_s_options, "default-path", "%s", cwd);
   
         if (unlock) {          if (unlock) {
                 if (argc != 0) {                  if (prepare_unlock(&msg, &buf, &len, argc) != 0)
                         log_warnx("can't specify a command when unlocking");  
                         exit(1);                          exit(1);
                 }  
                 cmdlist = NULL;  
                 if ((pass = getpass("Password: ")) == NULL)  
                         exit(1);  
                 cmdflags &= ~CMD_STARTSERVER;  
         } else {          } else {
                 if (argc == 0) {                  if (prepare_cmd(&msg, &buf, &len, argc, argv) != 0)
                         cmd = xmalloc(sizeof *cmd);                          exit(1);
                         cmd->entry = &cmd_new_session_entry;          }
                         cmd->entry->init(cmd, 0);  
   
                         cmdlist = xmalloc(sizeof *cmdlist);          if (unlock)
                         TAILQ_INIT(cmdlist);                  cmdflags &= ~CMD_STARTSERVER;
                         TAILQ_INSERT_HEAD(cmdlist, cmd, qentry);          else if (argc == 0)
                 } else {                  cmdflags |= CMD_STARTSERVER;
                         cmdlist = cmd_list_parse(argc, argv, &cause);          else {
                         if (cmdlist == NULL) {                  /*
                                 log_warnx("%s", cause);                   * It sucks parsing the command string twice (in client and
                                 exit(1);                   * later in server) but it is necessary to get the start server
                         }                   * flag.
                    */
                   if ((cmdlist = cmd_list_parse(argc, argv, &cause)) == NULL) {
                           log_warnx("%s", cause);
                           exit(1);
                 }                  }
                   cmdflags &= ~CMD_STARTSERVER;
                 TAILQ_FOREACH(cmd, cmdlist, qentry) {                  TAILQ_FOREACH(cmd, cmdlist, qentry) {
                         if (cmd->entry->flags & CMD_STARTSERVER) {                          if (cmd->entry->flags & CMD_STARTSERVER) {
                                 cmdflags |= CMD_STARTSERVER;                                  cmdflags |= CMD_STARTSERVER;
                                 break;                                  break;
                         }                          }
                 }                  }
                   cmd_list_free(cmdlist);
         }          }
   
         memset(&cctx, 0, sizeof cctx);          memset(&cctx, 0, sizeof cctx);
Line 420 
Line 472 
                 exit(1);                  exit(1);
         xfree(path);          xfree(path);
   
         b = buffer_create(BUFSIZ);          client_write_server(&cctx, msg, buf, len);
         if (unlock) {          memset(buf, 0, len);
                 cmd_send_string(b, pass);  
                 memset(pass, 0, strlen(pass));  
                 client_write_server(  
                     &cctx, MSG_UNLOCK, BUFFER_OUT(b), BUFFER_USED(b));  
         } else {  
                 cmd_list_send(cmdlist, b);  
                 cmd_list_free(cmdlist);  
                 client_fill_session(&cmddata);  
                 client_write_server2(&cctx, MSG_COMMAND,  
                     &cmddata, sizeof cmddata, BUFFER_OUT(b), BUFFER_USED(b));  
         }  
         buffer_destroy(b);  
   
         retcode = 0;          retcode = 0;
         for (;;) {          for (;;) {
Line 467 
Line 507 
                         retcode = 1;                          retcode = 1;
                         /* FALLTHROUGH */                          /* FALLTHROUGH */
                 case MSG_PRINT:                  case MSG_PRINT:
                         if (hdr.size > INT_MAX - 1)                          if (hdr.size < sizeof printdata)
                                 fatalx("bad MSG_PRINT size");                                  fatalx("bad MSG_PRINT size");
                         log_info("%.*s",                          buffer_read(cctx.srv_in, &printdata, sizeof printdata);
                             (int) hdr.size, BUFFER_OUT(cctx.srv_in));  
                         if (hdr.size != 0)                          printdata.msg[(sizeof printdata.msg) - 1] = '\0';
                                 buffer_remove(cctx.srv_in, hdr.size);                          log_info("%s", printdata.msg);
                         goto restart;                          goto restart;
                 case MSG_READY:                  case MSG_READY:
                         retcode = client_main(&cctx);                          retcode = client_main(&cctx);
Legend:
Removed from v.1.20  
changed lines
  Added in v.1.21