dselect/main.cc

   1 /*
   2  * dselect - Debian package maintenance user interface
   3  * main.cc - main program
   4  *
   5  * Copyright © 1994,1995 Ian Jackson <ian@chiark.greenend.org.uk>
   6  * Copyright © 2000,2001 Wichert Akkerman <wakkerma@debian.org>
   7  *
   8  * This is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include <config.h>
  23 #include <compat.h>
  24
  25 #include <sys/types.h>
  26 #include <sys/stat.h>
  27 #include <sys/wait.h>
  28
  29 #include <assert.h>
  30 #include <errno.h>
  31 #include <limits.h>
  32 #if HAVE_LOCALE_H
  33 #include <locale.h>
  34 #endif
  35 #include <ctype.h>
  36 #include <string.h>
  37 #include <fcntl.h>
  38 #include <dirent.h>
  39 #include <unistd.h>
  40 #include <stdlib.h>
  41 #include <stdio.h>
  42
  43 #if defined(HAVE_NCURSESW_TERM_H)
  44 #include <ncursesw/term.h>
  45 #elif defined(HAVE_NCURSES_TERM_H)
  46 #include <ncurses/term.h>
  47 #else
  48 #include <term.h>
  49 #endif
  50
  51 #include <dpkg/i18n.h>
  52 #include <dpkg/dpkg.h>
  53 #include <dpkg/dpkg-db.h>
  54 #include <dpkg/myopt.h>
  55
  56 #include "dselect.h"
  57 #include "bindings.h"
  58 #include "pkglist.h"
  59
  60 const char thisname[]= DSELECT;
  61 const char printforhelp[]= N_("Type dselect --help for help.");
  62
  63 modstatdb_rw readwrite;
  64 const char *admindir= ADMINDIR;
  65 FILE *debug;
  66 int expertmode= 0;
  67
  68 static keybindings packagelistbindings(packagelist_kinterps,packagelist_korgbindings);
  69
  70 struct table_t {
  71   const char *name;
  72   const int num;
  73 };
  74
  75 static const struct table_t colourtable[]= {
  76   {"black",     COLOR_BLACK     },
  77   {"red",       COLOR_RED       },
  78   {"green",     COLOR_GREEN     },
  79   {"yellow",    COLOR_YELLOW    },
  80   {"blue",      COLOR_BLUE      },
  81   {"magenta",   COLOR_MAGENTA   },
  82   {"cyan",      COLOR_CYAN      },
  83   {"white",     COLOR_WHITE     },
  84   {NULL, 0},
  85 };
  86
  87 static const struct table_t attrtable[]= {
  88   {"normal",    A_NORMAL        },
  89   {"standout",  A_STANDOUT      },
  90   {"underline", A_UNDERLINE     },
  91   {"reverse",   A_REVERSE       },
  92   {"blink",     A_BLINK         },
  93   {"bright",    A_BLINK         }, // on some terminals
  94   {"dim",       A_DIM           },
  95   {"bold",      A_BOLD          },
  96   {NULL, 0},
  97 };
  98
  99 /* A slightly confusing mapping from dselect's internal names to
 100  * the user-visible names.*/
 101 static const struct table_t screenparttable[]= {
 102   {"list",              list            },
 103   {"listsel",           listsel         },
 104   {"title",             title           },
 105   {"infohead",          thisstate       },
 106   {"pkgstate",          selstate        },
 107   {"pkgstatesel",       selstatesel     },
 108   {"listhead",          colheads        },
 109   {"query",             query           },
 110   {"info",              info            },
 111   {"infodesc",          info_head       },
 112   {"infofoot",          whatinfo        },
 113   {"helpscreen",        helpscreen      },
 114   {NULL, 0},
 115 };
 116
 117 /* Historical (patriotic?) colours. */
 118 struct colordata color[]= {
 119   /* fore      back            attr */
 120   {COLOR_WHITE,        COLOR_BLACK,    0                        }, // default, not used
 121   {COLOR_WHITE,        COLOR_BLACK,    0                        }, // list
 122   {COLOR_WHITE,        COLOR_BLACK,    A_REVERSE                }, // listsel
 123   {COLOR_WHITE,        COLOR_RED,      0                        }, // title
 124   {COLOR_WHITE,        COLOR_BLUE,     0                        }, // thisstate
 125   {COLOR_WHITE,        COLOR_BLACK,    A_BOLD                   }, // selstate
 126   {COLOR_WHITE,        COLOR_BLACK,    A_REVERSE | A_BOLD       }, // selstatesel
 127   {COLOR_WHITE,        COLOR_BLUE,     0                        }, // colheads
 128   {COLOR_WHITE,        COLOR_RED,      0                        }, // query
 129   {COLOR_WHITE,        COLOR_BLACK,    0                        }, // info
 130   {COLOR_WHITE,        COLOR_BLACK,    A_BOLD                   }, // info_head
 131   {COLOR_WHITE,        COLOR_BLUE,     0                        }, // whatinfo
 132   {COLOR_WHITE,        COLOR_BLACK,    0                        }, // help
 133 };
 134
 135 struct menuentry {
 136   const char *command;
 137   const char *key;
 138   const char *option;
 139   const char *menuent;
 140   urqfunction *fn;
 141 };
 142
 143 static const menuentry menuentries[]= {
 144   { "access",   N_("a"),        N_("[A]ccess"), N_("Choose the access method to use."),                 &urq_setup   },
 145   { "update",   N_("u"),        N_("[U]pdate"), N_("Update list of available packages, if possible."),  &urq_update  },
 146   { "select",   N_("s"),        N_("[S]elect"), N_("Request which packages you want on your system."),  &urq_list    },
 147   { "install",  N_("i"),        N_("[I]nstall"),N_("Install and upgrade wanted packages."),             &urq_install },
 148   { "config",   N_("c"),        N_("[C]onfig"), N_("Configure any packages that are unconfigured."),    &urq_config  },
 149   { "remove",   N_("r"),        N_("[R]emove"), N_("Remove unwanted software."),                        &urq_remove  },
 150   { "quit",     N_("q"),        N_("[Q]uit"),   N_("Quit dselect."),                                    &urq_quit    },
 151   { 0,          0,              N_("menu"),     0,                                                      &urq_menu    },
 152   { 0 }
 153 };
 154
 155 static const char programdesc[]=
 156       N_("Debian `%s' package handling frontend version %s.\n");
 157
 158 static const char copyrightstring[]= N_(
 159       "Copyright (C) 1994-1996 Ian Jackson.\n"
 160       "Copyright (C) 2000,2001 Wichert Akkerman.\n");
 161
 162 static const char licensestring[]= N_(
 163       "This is free software; see the GNU General Public License version 2 or\n"
 164       "later for copying conditions. There is NO warranty.\n");
 165
 166 static void DPKG_ATTR_NORET
 167 printversion(const struct cmdinfo *ci, const char *value)
 168 {
 169   printf(gettext(programdesc), DSELECT, DPKG_VERSION_ARCH);
 170   printf(gettext(copyrightstring));
 171   printf(gettext(licensestring), DSELECT);
 172
 173   m_output(stdout, _("<standard output>"));
 174
 175   exit(0);
 176 }
 177
 178 static void DPKG_ATTR_NORET
 179 usage(const struct cmdinfo *ci, const char *value)
 180 {
 181   int i;
 182
 183   printf(_(
 184 "Usage: %s [<option> ...] [<action> ...]\n"
 185 "\n"), DSELECT);
 186
 187   printf(_(
 188 "Options:\n"
 189 "  --admindir <directory>     Use <directory> instead of %s.\n"
 190 "  --expert                   Turn on expert mode.\n"
 191 "  --debug <file> | -D<file>  Turn on debugging, sending output to <file>.\n"
 192 "  --colour | --color screenpart:[foreground],[background][:attr[+attr+..]]\n"
 193 "                             Configure screen colours.\n"
 194 "\n"), ADMINDIR);
 195
 196   printf(_(
 197 "  --help                     Show this help message.\n"
 198 "  --version                  Show the version.\n"
 199 "\n"));
 200
 201   printf(_(
 202 "Actions:\n"
 203 "  access update select install config remove quit\n"
 204 "\n"));
 205
 206   printf(_("Screenparts:\n"));
 207   for (i=0; screenparttable[i].name; i++)
 208     printf("  %s", screenparttable[i].name);
 209   fputs("\n\n", stdout);
 210
 211   printf(_("Colours:\n"));
 212   for (i=0; colourtable[i].name; i++)
 213     printf("  %s", colourtable[i].name);
 214   fputs("\n\n", stdout);
 215
 216   printf(_("Attributes:\n"));
 217   for (i=0; attrtable[i].name; i++)
 218     printf("  %s", attrtable[i].name);
 219   fputs("\n\n", stdout);
 220
 221   m_output(stdout, _("<standard output>"));
 222
 223   exit(0);
 224 }
 225
 226 /* These are called by C code, so need to have C calling convention */
 227 extern "C" {
 228
 229   static void setdebug(const struct cmdinfo*, const char *v) {
 230     debug= fopen(v,"a");
 231     if (!debug) ohshite(_("couldn't open debug file `%.255s'\n"),v);
 232     setvbuf(debug,0,_IONBF,0);
 233   }
 234
 235   static void setexpert(const struct cmdinfo*, const char *v) {
 236     expertmode= 1;
 237   }
 238
 239   static int
 240   findintable(const struct table_t *table, const char *item, const char *tablename)
 241   {
 242     int i;
 243
 244     for (i= 0;  item && (table[i].name!=NULL); i++)
 245       if (strcasecmp(item, table[i].name) == 0)
 246         return table[i].num;
 247
 248     ohshit(_("Invalid %s `%s'\n"), tablename, item);
 249   }
 250
 251   /*
 252    *  The string's format is:
 253    *    screenpart:[forecolor][,backcolor][:[<attr>, ...]
 254    *  Examples: --color title:black,cyan:bright+underline
 255    *            --color list:red,yellow
 256    *            --color colheads:,green:bright
 257    *            --color selstate::reverse  // doesn't work FIXME
 258    */
 259   static void setcolor(const struct cmdinfo*, const char *string) {
 260     char *s;
 261     char *colours, *attributes, *attrib, *colourname;
 262     int screenpart, aval;
 263
 264     s = m_strdup(string); // strtok modifies strings, keep string const
 265     screenpart= findintable(screenparttable, strtok(s, ":"), _("screen part"));
 266     colours= strtok(NULL, ":");
 267     attributes= strtok(NULL, ":");
 268
 269     if ((colours == NULL || ! strlen(colours)) &&
 270         (attributes == NULL || ! strlen(attributes))) {
 271        ohshit(_("Null colour specification\n"));
 272     }
 273
 274     if (colours != NULL && strlen(colours)) {
 275       colourname= strtok(colours, ",");
 276       if (colourname != NULL && strlen(colourname)) {
 277         // normalize attributes to prevent confusion
 278         color[screenpart].attr= A_NORMAL;
 279        color[screenpart].fore=findintable(colourtable, colourname, _("colour"));
 280       }
 281       colourname= strtok(NULL, ",");
 282       if (colourname != NULL && strlen(colourname)) {
 283         color[screenpart].attr= A_NORMAL;
 284         color[screenpart].back=findintable(colourtable, colourname, _("colour"));
 285       }
 286     }
 287
 288     if (attributes != NULL && strlen(attributes)) {
 289       for (attrib= strtok(attributes, "+");
 290            attrib != NULL && strlen(attrib);
 291           attrib= strtok(NULL, "+")) {
 292                aval=findintable(attrtable, attrib, _("colour attribute"));
 293                if (aval == A_NORMAL) // set to normal
 294                        color[screenpart].attr= aval;
 295                else // add to existing attribs
 296                        color[screenpart].attr= color[screenpart].attr | aval;
 297       }
 298     }
 299   }
 300
 301 } /* End of extern "C" */
 302
 303 static const struct cmdinfo cmdinfos[]= {
 304   { "admindir",     0,   1,  0,  &admindir,  0               },
 305   { "debug",       'D',  1,  0,  0,          setdebug        },
 306   { "expert",      'E',  0,  0,  0,          setexpert       },
 307   { "help",        'h',  0,  0,  0,          usage           },
 308   { "version",      0,   0,  0,  0,          printversion    },
 309   { "color",        0,   1,  0,  0,          setcolor        }, /* US spelling */
 310   { "colour",       0,   1,  0,  0,          setcolor        }, /* UK spelling */
 311   { 0,              0,   0,  0,  0,          0               }
 312 };
 313
 314 static int cursesareon= 0;
 315 void curseson() {
 316   if (!cursesareon) {
 317     const char *cup, *smso;
 318     initscr();
 319     cup= tigetstr("cup");
 320     smso= tigetstr("smso");
 321     if (!cup || !smso) {
 322       endwin();
 323       if (!cup)
 324         fputs(_("Terminal does not appear to support cursor addressing.\n"),stderr);
 325       if (!smso)
 326         fputs(_("Terminal does not appear to support highlighting.\n"),stderr);
 327       fprintf(stderr,
 328               _("Set your TERM variable correctly, use a better terminal,\n"
 329                 "or make do with the per-package management tool %s.\n"),
 330               DPKG);
 331       ohshit(_("terminal lacks necessary features, giving up"));
 332     }
 333   }
 334   cursesareon= 1;
 335 }
 336
 337 void cursesoff() {
 338   if (cursesareon) {
 339     clear();
 340     refresh();
 341     endwin();
 342   }
 343   cursesareon=0;
 344 }
 345
 346 extern void *operator new(size_t size) {
 347   void *p;
 348   p= m_malloc(size);
 349   assert(p);
 350   return p;
 351 }
 352
 353 extern void operator delete(void *p) {
 354   free(p);
 355 }
 356
 357 urqresult urq_list(void) {
 358   readwrite= modstatdb_init(admindir,msdbrw_writeifposs);
 359
 360   curseson();
 361
 362   packagelist *l= new packagelist(&packagelistbindings);
 363   l->resolvesuggest();
 364   l->display();
 365   delete l;
 366
 367   modstatdb_shutdown();
 368   resetpackages();
 369   return urqr_normal;
 370 }
 371
 372 static void
 373 dme(int i, int so)
 374 {
 375   char buf[120];
 376   const menuentry *me= &menuentries[i];
 377   sprintf(buf," %c %d. %-11.11s %-80.80s ",
 378           so ? '*' : ' ', i,
 379           gettext(me->option),
 380           gettext(me->menuent));
 381
 382   int y,x;
 383   getmaxyx(stdscr,y,x);
 384
 385   attrset(so ? A_REVERSE : A_NORMAL);
 386   mvaddnstr(i+2,0, buf,x-1);
 387   attrset(A_NORMAL);
 388 }
 389
 390 static int
 391 refreshmenu(void)
 392 {
 393   char buf[2048];
 394   static int l,lockfd;
 395   static char *lockfile;
 396
 397   curseson(); cbreak(); noecho(); nonl(); keypad(stdscr,TRUE);
 398
 399   int y,x;
 400   getmaxyx(stdscr,y,x);
 401
 402   clear();
 403   attrset(A_BOLD);
 404   sprintf(buf, gettext(programdesc), DSELECT, DPKG_VERSION_ARCH);
 405   mvaddnstr(0,0,buf,x-1);
 406
 407   attrset(A_NORMAL);
 408   const struct menuentry *mep; int i;
 409   for (mep=menuentries, i=0; mep->option && mep->menuent; mep++, i++)
 410     dme(i,0);
 411
 412   attrset(A_BOLD);
 413   addstr(_("\n\n"
 414          "Move around with ^P and ^N, cursor keys, initial letters, or digits;\n"
 415          "Press <enter> to confirm selection.   ^L redraws screen.\n\n"));
 416
 417   attrset(A_NORMAL);
 418   addstr(gettext(copyrightstring));
 419   sprintf(buf, gettext(licensestring), DSELECT);
 420   addstr(buf);
 421
 422   l= strlen(admindir);
 423   lockfile= new char[l+sizeof(LOCKFILE)+2];
 424   strcpy(lockfile,admindir);
 425   strcpy(lockfile+l, "/" LOCKFILE);
 426   lockfd= open(lockfile, O_RDWR|O_CREAT|O_TRUNC, 0660);
 427   if (errno == EACCES || errno == EPERM)
 428     addstr(_("\n\n"
 429              "Read-only access: only preview of selections is available!"));
 430
 431   return i;
 432 }
 433
 434 urqresult urq_menu(void) {
 435 #define C(x) ((x)-'a'+1)
 436   int entries, c;
 437   entries= refreshmenu();
 438   int cursor=0;
 439   dme(0,1);
 440   for (;;) {
 441     refresh();
 442     do
 443       c= getch();
 444     while (c == ERR && errno == EINTR);
 445     if (c==ERR)  {
 446       if(errno != 0)
 447         ohshite(_("failed to getch in main menu"));
 448       else {
 449         clearok(stdscr,TRUE); clear(); refreshmenu(); dme(cursor,1);
 450       }
 451     }
 452
 453     if (c==C('n') || c==KEY_DOWN || c==' ' || c=='j') {
 454       dme(cursor,0); cursor++; cursor %= entries; dme(cursor,1);
 455     } else if (c==C('p') || c==KEY_UP || c==C('h') ||
 456                c==KEY_BACKSPACE || c==KEY_DC || c=='k') {
 457       dme(cursor,0); cursor+= entries-1; cursor %= entries; dme(cursor,1);
 458     } else if (c=='\n' || c=='\r' || c==KEY_ENTER) {
 459       clear(); refresh();
 460       switch (menuentries[cursor].fn()) { /* FIXME: trap errors in urq_... */
 461       case urqr_quitmenu:
 462         return urqr_quitmenu;
 463       case urqr_normal:
 464         cursor++; cursor %= entries;
 465       case urqr_fail:
 466         break;
 467       default:
 468         internerr("unknown menufn");
 469       }
 470       refreshmenu(); dme(cursor,1);
 471     } else if (c==C('l')) {
 472       clearok(stdscr,TRUE); clear(); refreshmenu(); dme(cursor,1);
 473     } else if (isdigit(c)) {
 474       char buf[2]; buf[0]=c; buf[1]=0; c=atoi(buf);
 475       if (c < entries) {
 476         dme(cursor,0); cursor=c; dme(cursor,1);
 477       } else {
 478         beep();
 479       }
 480     } else if (isalpha(c)) {
 481       c= tolower(c);
 482       int i = 0;
 483       while (i < entries && gettext(menuentries[i].key)[0] != c)
 484         i++;
 485       if (i < entries) {
 486         dme(cursor,0); cursor=i; dme(cursor,1);
 487       } else {
 488         beep();
 489       }
 490     } else {
 491       beep();
 492     }
 493   }
 494 }
 495
 496 urqresult urq_quit(void) {
 497   /* FIXME: check packages OK. */
 498   return urqr_quitmenu;
 499 }
 500
 501 int main(int, const char *const *argv) {
 502   jmp_buf ejbuf;
 503
 504   setlocale(LC_ALL, "");
 505   bindtextdomain(DSELECT, LOCALEDIR);
 506   textdomain(DSELECT);
 507
 508   if (setjmp(ejbuf)) { /* expect warning about possible clobbering of argv */
 509     cursesoff();
 510     error_unwind(ehflag_bombout); exit(2);
 511   }
 512   push_error_handler(&ejbuf,print_error_fatal,0);
 513
 514   loadcfgfile(DSELECT, cmdinfos);
 515   myopt(&argv,cmdinfos);
 516
 517   if (*argv) {
 518     const char *a;
 519     while ((a= *argv++) != 0) {
 520       const menuentry *me = menuentries;
 521       while (me->command && strcmp(me->command, a))
 522         me++;
 523       if (!me->command) badusage(_("unknown action string `%.50s'"),a);
 524       me->fn();
 525     }
 526   } else {
 527     urq_menu();
 528   }
 529
 530   cursesoff();
 531   standard_shutdown();
 532   return(0);
 533 }
 534