home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / utils / disk-man / mtools-3.000 / mtools-3 / mtools-3.0 / misc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-05-08  |  5.8 KB  |  336 lines
  1. /*
  2.  * Miscellaneous routines.
  3.  */
  4.  
  5. #include "sysincludes.h"
  6. #include "msdos.h"
  7. #include "stream.h"
  8. #include "vfat.h"
  9. #include "mtools.h"
  10.  
  11. char *get_homedir(void)
  12. {
  13.     struct passwd *pw;
  14.     int uid;
  15.     char *homedir;
  16.     char *username;
  17.     
  18.     homedir = getenv ("HOME");    
  19.     /* 
  20.      * first we call getlogin. 
  21.      * There might be several accounts sharing one uid 
  22.      */
  23.     if ( homedir )
  24.         return homedir;
  25.     
  26.     pw = 0;
  27.     
  28.     username = getenv("LOGNAME");
  29.     if ( !username )
  30.         username = getlogin();
  31.     if ( username )
  32.         pw = getpwnam( username);
  33.   
  34.     if ( pw == 0 ){
  35.         /* if we can't getlogin, look up the pwent by uid */
  36.         uid = geteuid();
  37.         pw = getpwuid(uid);
  38.     }
  39.     
  40.     /* we might still get no entry */
  41.     if ( pw )
  42.         return pw->pw_dir;
  43.     return 0;
  44. }
  45.  
  46. static FILE *tty=NULL;
  47. static int notty=0;    
  48. static int ttyfd=-1;
  49. static int tty_mode = -1; /* 1 for raw, 0 for cooked, -1 for initial */
  50. static int need_tty_reset = 0;
  51.  
  52.  
  53. #ifdef TCSANOW
  54.  
  55. /* we have tcsetattr & tcgetattr. Good */
  56. #define stty(a,b)        (void)tcsetattr(a,TCSANOW,b)
  57. #define gtty(a,b)        (void)tcgetattr(a,b)
  58. #ifdef TCIFLUSH
  59. #define discard_input(a) tcflush(a,TCIFLUSH)
  60. #else
  61. #define discard_input(a) /**/
  62. #endif
  63.  
  64. #else /* TCSANOW */
  65.  
  66. #ifndef TCSETS
  67. #define TCSETS TCSETA
  68. #define TCGETS TCGETA
  69. #define termios termio
  70. #endif
  71.  
  72. #define stty(a,b) (void)ioctl(a,TCSETS,(char *)b)
  73. #define gtty(a,b) (void)ioctl(a,TCGETS,(char *)b)
  74.  
  75. #ifdef TCIFLUSH
  76. #define discard_input(a) (void)ioctl(a,TCFLSH,TCIFLUSH)
  77. #else
  78. #define discard_input(a) /**/
  79. #endif
  80.  
  81. #endif /* TCSANOW */
  82.  
  83. #define restore_tty(a) stty(STDIN,a)
  84.  
  85.  
  86. #define SHFAIL    1
  87. #define STDIN ttyfd
  88. #define FAIL (-1)
  89. #define DONE 0
  90. static struct termios in_orig;
  91.  
  92. /*--------------- Signal Handler routines -------------*/
  93.  
  94. static void tty_time_out(void)
  95. {
  96.     int exit_code;
  97.     signal(SIGALRM, SIG_IGN);
  98.     if(tty && need_tty_reset)
  99.         restore_tty (&in_orig);    
  100. #if future
  101.     if (fail_on_timeout)
  102.         exit_code=SHFAIL;
  103.     else {
  104.         if (default_choice && mode_defined) {
  105.             if (yes_no) {
  106.                 if ('Y' == default_choice)
  107.                     exit_code=0;
  108.                 else
  109.                     exit_code=1;
  110.             } else
  111.                 exit_code=default_choice-minc+1;
  112.         } else
  113.             exit_code=DONE;
  114.     }
  115. #else
  116.     exit_code = DONE;
  117. #endif
  118.     exit(exit_code);
  119. }
  120.  
  121. void cleanup_and_exit(int code)
  122. { 
  123.     if(tty && need_tty_reset) {
  124.         restore_tty (&in_orig);
  125.         signal (SIGHUP, SIG_IGN);
  126.         signal (SIGINT, SIG_IGN);
  127.         signal (SIGTERM, SIG_IGN);
  128.         signal (SIGALRM, SIG_IGN);
  129.     }
  130.     exit(code);
  131. }
  132.  
  133. static void clean_up_and_fail(void)
  134. {
  135.     cleanup_and_exit(SHFAIL);
  136. }
  137.  
  138. static void set_raw_tty(int mode)
  139. {
  140.     struct termios in_raw;
  141.  
  142.     if(mode != tty_mode && mode != -1) {
  143.         /* Determine existing TTY settings */
  144.         gtty (STDIN, &in_orig);
  145.         need_tty_reset = 1;
  146.  
  147.         /*------ Restore original TTY settings on exit --------*/
  148.         signal (SIGHUP, (SIG_CAST)clean_up_and_fail);
  149.         signal (SIGINT, (SIG_CAST)clean_up_and_fail);
  150.         signal (SIGTERM, (SIG_CAST)clean_up_and_fail);
  151.         signal (SIGALRM, (SIG_CAST)tty_time_out);
  152.     
  153.         /* Change STDIN settings to raw */
  154.  
  155.         gtty (STDIN, &in_raw);
  156.         if(mode) {
  157.             in_raw.c_lflag &= ~ICANON;
  158.             in_raw.c_cc[VMIN]=1;
  159.             in_raw.c_cc[VTIME]=0;
  160.             stty (STDIN, &in_raw);
  161.         } else {
  162.             in_raw.c_lflag |= ICANON;
  163.             stty (STDIN, &in_raw);
  164.         }
  165.         tty_mode = mode;
  166.         discard_input(STDIN);
  167.     }
  168. }
  169.  
  170. FILE *opentty(int mode)
  171. {
  172.     if(notty)
  173.         return NULL;
  174.  
  175.     if (tty == NULL) {
  176.         ttyfd = open("/dev/tty", O_RDONLY);
  177.         if(ttyfd >= 0) {
  178.             tty = fdopen(ttyfd, "r");
  179.         }
  180.     }
  181.  
  182.     if  (tty == NULL){
  183.         if ( !isatty(0) ){
  184.             notty = 1;
  185.             return NULL;
  186.         }
  187.         ttyfd = 0;
  188.         tty = stdin;
  189.     }
  190.  
  191.     set_raw_tty(mode);
  192.     return tty;
  193. }
  194.  
  195. int ask_confirmation(char *format, char *p1, char *p2)
  196. {
  197.     char ans[10];
  198.  
  199.     if(!opentty(-1))
  200.         return 0;
  201.  
  202.     while (1) {
  203.         fprintf(stderr, format, p1, p2);
  204.         fflush(stderr);
  205.         fflush(opentty(-1));
  206.         if (mtools_raw_tty) {
  207.             ans[0] = fgetc(opentty(1));
  208.             fputs("\n", stderr);
  209.         } else {
  210.             fgets(ans,9, opentty(0));
  211.         }
  212.         if (ans[0] == 'y' || ans[0] == 'Y')
  213.             return 0;
  214.         if (ans[0] == 'n' || ans[0] == 'N')
  215.             return -1;
  216.     }
  217. }
  218.  
  219.  
  220. FILE *open_mcwd(char *mode)
  221. {
  222.     struct stat sbuf;
  223.     char file[EXPAND_BUF];
  224.     long now;
  225.     char *mcwd_path;
  226.     char *homedir;
  227.  
  228.     mcwd_path = getenv("MCWD");
  229.     if (mcwd_path == NULL || *mcwd_path == '\0'){
  230.         homedir= get_homedir();
  231.         if ( homedir ){
  232.             strncpy(file, homedir, MAXPATHLEN);
  233.             file[MAXPATHLEN]='\0';
  234.             strcat( file, "/.mcwd");
  235.         } else
  236.             strcpy(file,"/tmp/.mcwd");
  237.     } else
  238.         expand(mcwd_path,file);
  239.  
  240.     if (*mode == 'r'){
  241.         if (stat(file, &sbuf) < 0)
  242.             return NULL;
  243.         /*
  244.          * Ignore the info, if the file is more than 6 hours old
  245.          */
  246.         time(&now);
  247.         if (now - sbuf.st_mtime > 6 * 60 * 60) {
  248.             fprintf(stderr,
  249.                 "Warning: \"%s\" is out of date, removing it\n",
  250.                 file);
  251.             unlink(file);
  252.             return NULL;
  253.         }
  254.     }
  255.     
  256.     return  fopen(file, mode);
  257. }
  258.     
  259.  
  260. /* Fix the info in the MCWD file to be a proper directory name.
  261.  * Always has a leading separator.  Never has a trailing separator
  262.  * (unless it is the path itself).  */
  263.  
  264. char *fix_mcwd(char *ans)
  265. {
  266.     FILE *fp;
  267.     char *s;
  268.     char buf[BUFSIZ];
  269.  
  270.     fp = open_mcwd("r");
  271.     if(!fp){
  272.         strcpy(ans, "A:/");
  273.         return ans;
  274.     }
  275.  
  276.     if (!fgets(buf, BUFSIZ, fp))
  277.         return("A:/");
  278.  
  279.     buf[strlen(buf) -1] = '\0';
  280.     fclose(fp);
  281.                     /* drive letter present? */
  282.     s = buf;
  283.     if (buf[0] && buf[1] == ':') {
  284.         strncpy(ans, buf, 2);
  285.         ans[2] = '\0';
  286.         s = &buf[2];
  287.     } else 
  288.         strcpy(ans, "A:");
  289.                     /* add a leading separator */
  290.     if (*s != '/' && *s != '\\') {
  291.         strcat(ans, "/");
  292.         strcat(ans, s);
  293.     } else
  294.         strcat(ans, s);
  295.                     /* translate to upper case */
  296.     for (s = ans; *s; ++s) {
  297.         *s = toupper(*s);
  298.         if (*s == '\\')
  299.             *s = '/';
  300.     }
  301.                     /* if only drive, colon, & separator */
  302.     if (strlen(ans) == 3)
  303.         return(ans);
  304.                     /* zap the trailing separator */
  305.     if (*--s == '/')
  306.         *s = '\0';
  307.     return ans;
  308. }
  309.  
  310. int maximize(int *target, int max)
  311. {
  312.     if (*target > max)
  313.         *target = max;
  314.     return *target;
  315. }
  316.  
  317. int minimize(int *target, int min)
  318. {
  319.     if (*target < min)
  320.         *target = min;
  321.     return *target;
  322. }
  323.  
  324.  
  325. void *safe_malloc(size_t size)
  326. {
  327.     void *p;
  328.  
  329.     p = malloc(size);
  330.     if(!p){
  331.         fprintf(stderr,"Out of memory error\n");
  332.         exit(1);
  333.     }
  334.     return p;
  335. }
  336.