utils/ion-completefile/ion-completefile.c

   1 /*
   2  * ion/share/ion-completefile/ion-completefile.c
   3  */
   4
   5 /****************************************************************************/
   6 /*                                                                          */
   7 /* Copyright 1992 Simmule Turner and Rich Salz.  All rights reserved.       */
   8 /*                                                                          */
   9 /* This software is not subject to any license of the American Telephone    */
  10 /* and Telegraph Company or of the Regents of the University of California. */
  11 /*                                                                          */
  12 /* Permission is granted to anyone to use this software for any purpose on  */
  13 /* any computer system, and to alter it and redistribute it freely, subject */
  14 /* to the following restrictions:                                           */
  15 /* 1. The authors are not responsible for the consequences of use of this   */
  16 /*    software, no matter how awful, even if they arise from flaws in it.   */
  17 /* 2. The origin of this software must not be misrepresented, either by     */
  18 /*    explicit claim or by omission.  Since few users ever read sources,    */
  19 /*    credits must appear in the documentation.                             */
  20 /* 3. Altered versions must be plainly marked as such, and must not be      */
  21 /*    misrepresented as being the original software.  Since few users       */
  22 /*    ever read sources, credits must appear in the documentation.          */
  23 /* 4. This notice may not be removed or altered.                            */
  24 /*                                                                          */
  25 /****************************************************************************/
  26 /*                                                                          */
  27 /*  This is a line-editing library, it can be linked into almost any        */
  28 /*  program to provide command-line editing and recall.                     */
  29 /*                                                                          */
  30 /*  Posted to comp.sources.misc Sun, 2 Aug 1992 03:05:27 GMT                */
  31 /*      by rsalz@osf.org (Rich $alz)                                        */
  32 /*                                                                          */
  33 /****************************************************************************/
  34 /*                                                                          */
  35 /*  The version contained here has some modifications by awb@cstr.ed.ac.uk  */
  36 /*  (Alan W Black) in order to integrate it with the Edinburgh Speech Tools */
  37 /*  library and Scheme-in-one-defun in particular.  All modifications to    */
  38 /*  to this work are continued with the same copyright above.  That is      */
  39 /*  This version editline does not have the the "no commercial use"         */
  40 /*  restriction that some of the rest of the EST library may have           */
  41 /*  awb Dec 30 1998                                                         */
  42 /*                                                                          */
  43 /****************************************************************************/
  44 /*  $Revision: 1.2 $
  45  **
  46  **  History and file completion functions for editline library.
  47  */
  48
  49
  50 /*
  51  * Adapted for use with Ion and tilde-expansion added by
  52  * Tuomo Valkonen <tuomov@cc.tut.fi>, 2000-08-23.
  53  */
  54
  55 #include <sys/param.h>
  56 #include <sys/types.h>
  57 #include <stdio.h>
  58 #include <stdlib.h>
  59 #include <dirent.h>
  60 #include <string.h>
  61 #include <unistd.h>
  62 #include <sys/stat.h>
  63 #include <pwd.h>
  64 /* needed for NGROUPS_MAX on Solaris 10 */
  65 #include <limits.h>
  66
  67 #include <libtu/util.h>
  68 #include <libtu/types.h>
  69 #include <libtu/misc.h>
  70 #include <libtu/output.h>
  71
  72 #define STRDUP(X) scopy(X)
  73 #define DISPOSE(X) free(X)
  74 #define NEW(T, X)  ALLOC_N(T, X)
  75 #define STATIC static
  76 #define EL_CONST const
  77 #define SIZE_T int
  78 #define MEM_INC 64
  79 #define COPYFROMTO(new, p, len) \
  80         (void)memcpy((char *)(new), (char *)(p), (int)(len))
  81
  82 #ifndef NGROUPS
  83 /* Hopefully one of these is defined... */
  84 #define NGROUPS NGROUPS_MAX
  85 #endif
  86
  87 typedef struct dirent DIRENTRY;
  88
  89 static void el_add_slash(char *path,char *p)
  90 {
  91         struct stat sb;
  92
  93         if (stat(path, &sb) >= 0)
  94                 (void)strcat(p, S_ISDIR(sb.st_mode) ? "/" : " ");
  95 }
  96
  97 static int el_is_directory(char *path)
  98 {
  99         struct stat sb;
 100
 101         if ((stat(path, &sb) >= 0) && S_ISDIR(sb.st_mode))
 102                 return 1;
 103         else
 104                 return 0;
 105 }
 106
 107 static int el_is_executable(char *path)
 108 {
 109         unsigned int t_uid = geteuid();
 110         gid_t t_gids[NGROUPS];
 111         int groupcount;
 112         struct stat sb;
 113         int i;
 114
 115         groupcount = getgroups(NGROUPS, t_gids);
 116
 117         if((stat(path, &sb) >= 0) && S_ISREG(sb.st_mode)) {
 118                 /* Normal file, see if we can execute it. */
 119
 120                 if (sb.st_mode & S_IXOTH) { /* All can execute */
 121                         return (1);
 122                 }
 123                 if (sb.st_uid == t_uid && (sb.st_mode & S_IXUSR)) {
 124                         return (1);
 125                 }
 126                 if (sb.st_mode & S_IXGRP) {
 127                         for (i = 0; i < groupcount; i++) {
 128                             if (sb.st_gid == t_gids[i]) {
 129                                 return (1);
 130                             }
 131                         }
 132                 }
 133         }
 134         return (0);
 135 }
 136
 137
 138 /*
 139  **  strcmp-like sorting predicate for qsort.
 140  */
 141 /*STATIC int compare(EL_CONST void *p1,EL_CONST void *p2)
 142  {
 143  EL_CONST char  **v1;
 144  EL_CONST char  **v2;
 145  *
 146  v1 = (EL_CONST char **)p1;
 147  v2 = (EL_CONST char **)p2;
 148  return strcmp(*v1, *v2);
 149  }*/
 150
 151 /*
 152  **  Fill in *avp with an array of names that match file, up to its length.
 153  **  Ignore . and .. .
 154  */
 155 static int FindMatches(char *dir,char *file,char ***avp)
 156 {
 157     char        **av;
 158     char        **new;
 159     char        *p;
 160     DIR         *dp;
 161     DIRENTRY    *ep;
 162     SIZE_T      ac;
 163     SIZE_T      len;
 164
 165         if(*dir=='\0')
 166                 dir=".";
 167
 168     if ((dp = opendir(dir)) == NULL)
 169                 return 0;
 170
 171     av = NULL;
 172     ac = 0;
 173     len = strlen(file);
 174     while ((ep = readdir(dp)) != NULL) {
 175                 p = ep->d_name;
 176                 if (p[0] == '.' && (p[1] == '\0' || (p[1] == '.' && p[2] == '\0')))
 177                         continue;
 178                 if (len && strncmp(p, file, len) != 0)
 179                         continue;
 180
 181                 if ((ac % MEM_INC) == 0) {
 182                         if ((new = NEW(char*, ac + MEM_INC)) == NULL)
 183                                 break;
 184                         if (ac) {
 185                                 COPYFROMTO(new, av, ac * sizeof (char **));
 186                                 DISPOSE(av);
 187                         }
 188                         *avp = av = new;
 189                 }
 190
 191                 if ((av[ac] = STRDUP(p)) == NULL) {
 192                         if (ac == 0)
 193                                 DISPOSE(av);
 194                         break;
 195                 }
 196                 ac++;
 197     }
 198
 199     /* Clean up and return. */
 200     (void)closedir(dp);
 201         /*    if (ac)
 202          qsort(av, ac, sizeof (char **), compare);*/
 203     return ac;
 204 }
 205
 206
 207 /*
 208  ** Slight modification on FindMatches, to search through current PATH
 209  **
 210  */
 211 static int FindFullPathMatches(char *file,char ***avp)
 212 {
 213     char        **av;
 214     char        **new;
 215     char        *p;
 216     char    *path = getenv("PATH");
 217     char    t_tmp[1024];
 218     char    *t_path;
 219     char    *t_t_path;
 220     DIR         *dp;
 221     DIRENTRY*ep;
 222     SIZE_T      ac;
 223     SIZE_T      len;
 224
 225     t_path = strdup(path);
 226     t_t_path = t_path;
 227
 228     av = NULL;
 229     ac = 0;
 230
 231     t_t_path = strtok(t_path, ":\n\0");
 232     while (t_t_path) {
 233                 if ((dp = opendir(t_t_path)) == NULL) {
 234                         t_t_path = strtok(NULL, ":\n\0");
 235                         continue;
 236                 }
 237
 238                 len = strlen(file);
 239                 while ((ep = readdir(dp)) != NULL) {
 240                         p = ep->d_name;
 241                         if (p[0] == '.' && (p[1] == '\0' || (p[0] == '.' &&
 242                                                                                                  p[1] == '.' &&
 243                                                                                                  p[2] == '\0'))) {
 244                                 continue;
 245                         }
 246                         if (len && strncmp(p, file, len) != 0) {
 247                                 continue;
 248                         }
 249
 250                         snprintf(t_tmp, 1024, "%s/%s", t_t_path, p);
 251                         if(!el_is_executable(t_tmp)) {
 252                                 continue;
 253                         }
 254
 255                         if ((ac % MEM_INC) == 0) {
 256                                 if ((new = NEW(char*, ac + MEM_INC)) == NULL) {
 257                                         break;
 258                                 }
 259                                 if (ac) {
 260                                         COPYFROMTO(new, av, ac * sizeof (char **));
 261                                         DISPOSE(av);
 262                                 }
 263                                 *avp = av = new;
 264                         }
 265                         if ((av[ac] = STRDUP(p)) == NULL) {
 266                                 if (ac == 0)
 267                                         DISPOSE(av);
 268                                 break;
 269                         }
 270                         ac++;
 271                 }
 272                 (void)closedir(dp);
 273                 t_t_path = strtok(NULL, ":\n\0");
 274
 275
 276     } /* t_path-while */
 277
 278     /* Clean up and return. */
 279
 280     /*if (ac)
 281          qsort(av, ac, sizeof (char **), compare); */
 282     free(t_path);
 283
 284     return ac;
 285 }
 286
 287
 288 /*
 289  **  Split a pathname into allocated directory and trailing filename parts.
 290  */
 291 STATIC int SplitPath(const char *path,char **dirpart,char **filepart)
 292 {
 293     static char DOT[] = "./";
 294     char        *dpart;
 295     char        *fpart;
 296
 297     if ((fpart = strrchr(path, '/')) == NULL) {
 298                 /* No slashes in path */
 299                 if ((dpart = STRDUP(DOT)) == NULL)
 300                         return -1;
 301                 if ((fpart = STRDUP(path)) == NULL) {
 302                         DISPOSE(dpart);
 303                         return -1;
 304                 }
 305     }else{
 306                 if ((dpart = STRDUP(path)) == NULL)
 307                         return -1;
 308                 /* Include the slash -- Tuomo */
 309                 dpart[fpart - path + 1] = '\0';
 310                 if ((fpart = STRDUP(++fpart)) == NULL) {
 311                         DISPOSE(dpart);
 312                         return -1;
 313                 }
 314                 /* Root no longer a special case due above -- Tuomo
 315                  if (dpart[0] == '\0')
 316                  {
 317                  dpart[0] = '/';
 318                  dpart[1] = '\0';
 319                  }
 320                  */
 321     }
 322     *dirpart = dpart;
 323     *filepart = fpart;
 324     return 0;
 325 }
 326
 327 /*
 328  **  Split a pathname into allocated directory and trailing filename parts.
 329  */
 330 STATIC int SplitRelativePath(const char *path,char **dirpart,char **filepart)
 331 {
 332     static char DOT[] = "./";
 333     static char EOL[] = "\0";
 334     char *dpart;
 335     char *fpart;
 336
 337     if ((fpart = strrchr(path, '/')) == NULL) {
 338                 /* No slashes in path */
 339                 if ((dpart = STRDUP(EOL)) == NULL)
 340                         return -1;
 341                 if ((fpart = STRDUP(path)) == NULL) {
 342                         DISPOSE(dpart);
 343                         return -1;
 344                 }
 345     }
 346     else {
 347                 if ((dpart = STRDUP(path)) == NULL)
 348                         return -1;
 349                 /* Include the slash -- Tuomo */
 350                 dpart[fpart - path + 1] = '\0';
 351                 if ((fpart = STRDUP(++fpart)) == NULL) {
 352                         DISPOSE(dpart);
 353                         return -1;
 354                 }
 355                 /* Root no longer a special case due above -- Tuomo
 356                  if (dpart[0] == '\0')
 357                  {
 358                  dpart[0] = '/';
 359                  dpart[1] = '\0';
 360                  }
 361                  */
 362     }
 363     *dirpart = dpart;
 364     *filepart = fpart;
 365     return 0;
 366 }
 367
 368 /*
 369  **  Attempt to complete the pathname, returning an allocated copy.
 370  **  Fill in *unique if we completed it, or set it to 0 if ambiguous.
 371  */
 372 #if 0
 373 static char *el_complete(char *pathname,int *unique)
 374 {
 375     char        **av;
 376     char        *dir;
 377     char        *file;
 378     char        *new;
 379     char        *p;
 380     SIZE_T      ac;
 381     SIZE_T      end;
 382     SIZE_T      i;
 383     SIZE_T      j;
 384     SIZE_T      len;
 385
 386     if (SplitPath(pathname, &dir, &file) < 0)
 387                 return NULL;
 388
 389     if ((ac = FindMatches(dir, file, &av)) == 0) {
 390                 DISPOSE(dir);
 391                 DISPOSE(file);
 392                 return NULL;
 393     }
 394
 395     p = NULL;
 396     len = strlen(file);
 397     if (ac == 1) {
 398                 /* Exactly one match -- finish it off. */
 399                 *unique = 1;
 400                 j = strlen(av[0]) - len + 2;
 401                 if ((p = NEW(char, j + 1)) != NULL) {
 402                         COPYFROMTO(p, av[0] + len, j);
 403                         if ((new = NEW(char, strlen(dir) + strlen(av[0]) + 2)) != NULL) {
 404                                 (void)strcpy(new, dir);
 405                                 (void)strcat(new, "/");
 406                                 (void)strcat(new, av[0]);
 407                                 el_add_slash(new, p);
 408                                 DISPOSE(new);
 409                         }
 410                 }
 411     }
 412     else {
 413                 *unique = 0;
 414                 if (len) {
 415                         /* Find largest matching substring. */
 416                         for (i = len, end = strlen(av[0]); i < end; i++)
 417                         for (j = 1; j < ac; j++)
 418                     if (av[0][i] != av[j][i])
 419                                 goto breakout;
 420                 breakout:
 421                         if (i > len) {
 422                                 j = i - len + 1;
 423                                 if ((p = NEW(char, j)) != NULL) {
 424                                         COPYFROMTO(p, av[0] + len, j);
 425                                         p[j - 1] = '\0';
 426                                 }
 427                         }
 428                 }
 429     }
 430
 431     /* Clean up and return. */
 432     DISPOSE(dir);
 433     DISPOSE(file);
 434     for (i = 0; i < ac; i++)
 435                 DISPOSE(av[i]);
 436     DISPOSE(av);
 437     return p;
 438 }
 439 #endif
 440
 441 static int complete_homedir(const char *username, char ***cp_ret, char **beg)
 442 {
 443         struct passwd *pw;
 444         char *name;
 445         char **cp;
 446         int n=0, l=strlen(username);
 447
 448         *cp_ret=NULL;
 449
 450         for(pw=getpwent(); pw!=NULL; pw=getpwent()){
 451                 name=pw->pw_name;
 452
 453                 if(l && strncmp(name, username, l))
 454                         continue;
 455
 456                 name=scat3("~", name, "/");
 457
 458                 if(name==NULL){
 459                         warn_err();
 460                         continue;
 461                 }
 462
 463                 cp=REALLOC_N(*cp_ret, char*, n, n+1);
 464
 465                 if(cp==NULL){
 466                         warn_err();
 467                         free(name);
 468                         if(*cp_ret!=NULL)
 469                         free(*cp_ret);
 470                 }else{
 471                         cp[n]=name;
 472                         n++;
 473                         *cp_ret=cp;
 474                 }
 475         }
 476
 477         endpwent();
 478
 479         if(n==1){
 480                 name=**cp_ret;
 481                 name[strlen(name)-1]='\0';
 482                 pw=getpwnam(name+1);
 483                 if(pw!=NULL && pw->pw_dir!=NULL){
 484                         name=scat(pw->pw_dir, "/");
 485                         if(name!=NULL){
 486                                 free(**cp_ret);
 487                                 **cp_ret=name;
 488                         }
 489                 }
 490         }
 491
 492         return n;
 493 }
 494
 495 /*
 496  * ret: 0 not a home directory,
 497  *              1 home directory (repath set)
 498  *              2 someone's home directory
 499  */
 500 static int tilde_complete(char *path, char **retpath)
 501 {
 502         char *home;
 503         char *p;
 504         struct passwd *pw;
 505
 506         if(*path!='~')
 507                 return 0;
 508
 509         if(*(path+1)!='/' && *(path+1)!='\0'){
 510                 p=strchr(path, '/');
 511
 512                 if(p==NULL)
 513                         return 2;
 514
 515                 *p='\0';
 516                 pw=getpwnam(path+1);
 517                 *p='/';
 518
 519                 if(pw==NULL)
 520                         return 0;
 521
 522                 home=pw->pw_dir;
 523         }else{
 524                 p=path+1;
 525                 home=getenv("HOME");
 526         }
 527
 528         if(home!=NULL){
 529                 if(*p=='\0')
 530                         *retpath=scat3(home, p, "/");
 531                 else
 532                         *retpath=scat(home, p);
 533         }
 534
 535         return (*retpath!=NULL);
 536 }
 537
 538
 539 /*
 540  **  Return all possible completions.
 541  */
 542 int do_complete_file(char *pathname, char ***avp, char **beg,
 543                                          void *unused)
 544 {
 545     char        *dir;
 546     char        *file, *path=NULL, *tt;
 547     int         ac=0, i;
 548
 549     switch(tilde_complete(pathname, &path)){
 550     case 0:
 551                 i=SplitPath(pathname, &dir, &file);
 552                 break;
 553     case 2:
 554                 return complete_homedir(pathname+1, avp, beg);
 555     default:
 556                 i=SplitPath(path, &dir, &file);
 557     }
 558
 559     if(i<0)
 560                 return 0;
 561
 562     ac=FindMatches(dir, file, avp);
 563
 564     DISPOSE(file);
 565
 566     if(ac==0 && path!=NULL){
 567                 *avp=ALLOC(char*);
 568                 if(*avp==NULL)
 569                         return 0;
 570                 **avp=path;
 571                         return 1;
 572     }else if(path!=NULL){
 573                 free(path);
 574     }
 575
 576     /* Identify directories with trailing / */
 577     for(i=0; i<ac; i++){
 578                 path = NEW(char,strlen(dir)+strlen((*avp)[i])+3);
 579                 sprintf(path,"%s/%s",dir,(*avp)[i]);
 580                 if(el_is_directory(path)){
 581                         tt = NEW(char,strlen((*avp)[i])+2);
 582                         sprintf(tt,"%s/",(*avp)[i]);
 583                         DISPOSE((*avp)[i]);
 584                         (*avp)[i] = tt;
 585                 }
 586                 DISPOSE(path);
 587     }
 588
 589     *beg=dir;
 590
 591     return ac;
 592 }
 593
 594
 595 /*
 596  **  Return all possible completions.
 597  */
 598 int do_complete_file_with_path(char *pathname, char ***avp, char **beg,
 599                                                            void *unused)
 600 {
 601     char        *dir;
 602     char        *file, *path=NULL, *tt;
 603     int         ac=0, i, dcomp=FALSE;
 604
 605     switch(tilde_complete(pathname, &path)){
 606     case 0:
 607                 i=SplitRelativePath(pathname, &dir, &file);
 608                 break;
 609     case 2:
 610                 return complete_homedir(pathname+1, avp, beg);
 611     default:
 612                 i=SplitPath(path, &dir, &file);
 613     }
 614
 615     if(i<0)
 616                 return 0;
 617
 618     if(*dir=='\0')
 619                 ac=FindFullPathMatches(file, avp); /* No slashes in path so far. */
 620
 621         if(ac==0){
 622                 if(*dir=='\0'){
 623                         dir=scopy("./");
 624                         if(dir==NULL){
 625                                 warn_err();
 626                                 return 0;
 627                         }
 628                 }
 629                 ac=FindMatches(dir, file, avp);
 630                 dcomp=TRUE;
 631         }
 632
 633     DISPOSE(file);
 634
 635     if(ac==0 && path!=NULL){
 636                 *avp=ALLOC(char*);
 637                 if(*avp==NULL)
 638                         return 0;
 639                 **avp=path;
 640                         return 1;
 641     }else if(path!=NULL){
 642                 free(path);
 643     }
 644
 645     /* Identify directories with trailing / */
 646         if(dcomp){
 647             for (i = 0; i < ac; i++) {
 648                         path = NEW(char,strlen(dir)+strlen((*avp)[i])+3);
 649                         sprintf(path,"%s/%s",dir,(*avp)[i]);
 650                         if (el_is_directory(path)) {
 651                                 tt = NEW(char,strlen((*avp)[i])+2);
 652                                 sprintf(tt,"%s/",(*avp)[i]);
 653                                 DISPOSE((*avp)[i]);
 654                                 (*avp)[i] = tt;
 655                         }
 656                         DISPOSE(path);
 657             }
 658         }
 659
 660     *beg=dir;
 661
 662     return ac;
 663 }
 664
 665
 666
 667 int main(int argc, char *argv[])
 668 {
 669         char **avp=NULL;
 670         char *beg=NULL;
 671         bool wp=FALSE;
 672         int i, j, n;
 673
 674         libtu_init(argv[0]);
 675
 676         for(i=1; i<argc; i++){
 677                 if(strcmp(argv[i], "-h")==0){
 678                         printf("Usage: ion-completefile [-help] [-wp] [to_complete...]\n");
 679                         return EXIT_SUCCESS;
 680                 }
 681         }
 682
 683         for(i=1; i<argc; i++){
 684                 if(strcmp(argv[i], "-wp")==0){
 685                         wp=TRUE;
 686                 }else{
 687                         if(wp){
 688                                 n=do_complete_file_with_path(argv[i], &avp, &beg, NULL);
 689                         }else{
 690                                 n=do_complete_file(argv[i], &avp, &beg, NULL);
 691                         }
 692
 693                         if(beg){
 694                                 printf("%s\n", beg);
 695                                 free(beg);
 696                                 beg=NULL;
 697                         }else{
 698                                 printf("\n");
 699                         }
 700
 701
 702                         if(avp){
 703                                 for(j=0; j<n; j++){
 704                                         printf("%s\n", avp[j]);
 705                                         free(avp[j]);
 706                                 }
 707                                 free(avp);
 708                                 avp=NULL;
 709                         }
 710                 }
 711         }
 712
 713         return EXIT_SUCCESS;
 714 }