home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / forut062.zip / ForUtil-0.62 / lib / environment.c < prev    next >
C/C++ Source or Header  |  1996-11-11  |  11KB  |  437 lines
  1. #ifndef lint
  2. static char rcsId[]="$Header: /usr/local/rcs/ForUtil/lib/RCS/environment.c,v 1.21 1996/08/27 19:19:48 koen Exp koen $";
  3. #endif
  4. /*****
  5. * environment.c : environment scanning routines for libforUtil
  6. *
  7. * This file Version:     $Revision: 1.21 $
  8. *
  9. * Creation date:     03/18/1996 
  10. * Last Modification:    $Date: 1996/08/27 19:19:48 $ 
  11. * By:            $Author: koen $
  12. * Current State:    $State: Exp $
  13. * 
  14. * Author:        koen
  15. * (C)1995 Ripley Software Development
  16. * All Rights Reserved
  17. *****/ 
  18. /*****
  19. * ChangeLog
  20. * $Log: environment.c,v $
  21. * Revision 1.21  1996/08/27 19:19:48  koen
  22. * msdos related updates
  23. *
  24. * Revision 1.20  1996/08/07 21:17:40  koen
  25. * moved all msdos passwd emulation routines to msdospwd.c
  26. *
  27. * Revision 1.19  1996/08/02 14:52:52  koen
  28. * Replaced forLibP.h with forutil.h
  29. *
  30. * Revision 1.18  1996/07/30 02:02:37  koen
  31. * Reordered include files.
  32. *
  33. * Revision 1.17  1996/07/16 09:19:02  koen
  34. * added an extra LOGIN if for msdos implementation of getpwuid. 
  35. * Corrected a bug in make_directory
  36. *
  37. * Revision 1.16  1996/05/06 00:36:43  koen
  38. * Adapted for MSDOS: added bogus getpwent & getpwnam functions.
  39. *
  40. * Revision 1.15  1996/03/08 15:32:11  koen
  41. * Moved all Open Include database stuff to database.c
  42. *
  43. * Revision 1.14  1996/03/06 17:18:04  koen
  44. * Working on open_selected stuff: a version which uses dbm, and a simple one 
  45. * not using dbm. Removed the previously existing XXXXSearch routines 
  46. * completely, the new routines are much faster.
  47. *
  48. * Revision 1.13  1996/02/28 02:55:52  koen
  49. * Added make_directory and string_to_file routines.
  50. *
  51. * Revision 1.12  1996/02/19 01:29:38  koen
  52. * Added lots of #ifdef VERBOSE fprintf... #endif lines.
  53. *
  54. * Revision 1.11  1996/02/14 01:52:58  koen
  55. * Added the scan_for_(home,env_var,environment) routines + stuff to compile 
  56. * misc.c standalone if TEST is defined.
  57. *
  58. * Revision 1.10  1996/02/13 19:21:00  koen
  59. * Removed all x-related stuff to NeditUtils.c and GenUtils.c
  60. * Moved the file-handling routines from GenUtils.c to here.
  61. *
  62. * Revision 1.8  1995/11/24  03:26:17  koen
  63. * Added the XPromptMessage function: a wrapper for the DialogF of type 
  64. * DF_PROMPT.
  65. * Corrected return values for CheckIfSaved.
  66. *
  67. * Revision 1.7  1995/11/22  03:26:09  koen
  68. * Changed CheckIfSaved to use DialogF instead of PostWarningBox. The latter
  69. * doesn't seem to work under Linux.
  70. *
  71. * Revision 1.6  1995/11/17  01:44:45  koen
  72. * Corrected a number of small bugs occuring in lint. Removed all runtime
  73. * tracing information.
  74. *
  75. * Revision 1.5  1995/11/14  04:08:10  koen
  76. * Code clean up.
  77. *
  78. * Revision 1.4  1995/11/12  23:02:41  koen
  79. * modified get_home_dir, user's home directory is now returned in the
  80. * argument **home_dir. Previous form returned a char*, which gave
  81. * a casting warning when used.
  82. *
  83. * Revision 1.2  1995/10/31  17:32:46  koen
  84. * new source file Id record
  85. *
  86. * Revision 1.1  1995/10/09  01:49:43  root
  87. * Initial revision
  88. *
  89. *****/
  90. /* needed to prevent multiple variable decls under MSDOS in sysdeps.h */
  91. #define LIBRARY_OBJECT
  92.  
  93. /* include this before anything else */
  94. #ifdef HAVE_CONFIG_H
  95. #include "autoconf.h"
  96. #endif
  97.  
  98. #include <stdio.h> 
  99. #include <stdlib.h>
  100. #include <ctype.h> 
  101. #include <errno.h>
  102. #include <fcntl.h>
  103. #include <string.h>
  104. #include <sys/types.h>
  105. #include <sys/stat.h>
  106.  
  107. #include "memmacros.h"
  108. #include "forutil.h"
  109. #include "msdospwd.h"
  110.  
  111. /*
  112. * permissions to use for directory creation, rwx for user, 
  113. * rx for group and others. Change if you do not like this.
  114. */
  115. #ifndef __MSDOS__
  116. #define DIR_PERM (S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH)
  117. #endif
  118.  
  119. /****
  120. * Private data and function prototypes
  121. ****/
  122. static struct passwd *user_pwd = NULL;
  123.  
  124. /*****
  125. * get the user id of the current user
  126. * If root is using this, it's gonna get called every time, but what
  127. * the heck, root shouldn't be doing any development as root anyway...
  128. *****/
  129. static uid_t 
  130. get_user_id(void)
  131. {
  132.     static uid_t user_id;
  133.     if(user_id == 0)
  134.         user_id = getuid();
  135.     return(user_id);
  136. }
  137.  
  138. /*****
  139. * return a passwd for the current user.
  140. * If it fails, default to name <unknown> and \tmp as home dir and
  141. * tell the user what will happen.
  142. *****/
  143. static void 
  144. get_user_info(void)
  145. {
  146.     if(user_pwd == NULL)
  147.     {
  148.         /* get the user data from the passwd file */
  149.         user_pwd = getpwuid(get_user_id());
  150.         if(user_pwd == NULL)
  151.         {
  152.             static char *temp_path;
  153.             /*
  154.             * no passwd info found, set name fields to <unknown> and try
  155.             * to figure out what to use as pw_dir: try TMP, TEMP or /tmp 
  156.             */
  157.             if((temp_path = getenv("TMP")) == NULL)
  158.                 if((temp_path = getenv("TEMP")) == NULL)
  159. #ifdef __MSDOS__    /* current directory */
  160.                     temp_path = ".\\";
  161. #else
  162.                     temp_path = "/tmp";
  163. #endif
  164.             fprintf(stderr, "Hmm, I cannot figure out who you are. "
  165.                 "Using %s for temporary storage.\n",
  166.                 temp_path);
  167.             checked_malloc(user_pwd,1,struct passwd);
  168.             user_pwd->pw_name = "<unknown>";
  169.             user_pwd->pw_gecos = "<unknown>";
  170.             user_pwd->pw_dir = temp_path;
  171.         }
  172.     }
  173. }
  174.  
  175. /****
  176. * get the login name of the user
  177. ****/
  178. char 
  179. *get_user_login(void)
  180. {
  181.     get_user_info();
  182.     return(user_pwd->pw_name);
  183. }
  184.  
  185. /****
  186. * get the real name of the user
  187. ****/
  188. char 
  189. *get_user_name(void)
  190. {
  191.     get_user_info();
  192.     return(user_pwd->pw_gecos);
  193. }
  194.  
  195. /****
  196. * get the home directory of the user
  197. ****/
  198. void 
  199. get_home_dir(char **home_dir)
  200. {
  201.     get_user_info();
  202.     *home_dir = user_pwd->pw_dir;
  203.     return;
  204. }
  205.  
  206. /****
  207. * Scan for referenced home directories by the char ~ in a string
  208. ****/
  209. static void
  210. scan_for_home(char *file)
  211. {
  212.     char *newfile;
  213.     struct passwd *user_info = NULL;
  214.     char *chPtr = NULL;
  215.     int i = 0;
  216.  
  217.     /* scratch memory */
  218.     checked_alloca(newfile, MAXPATHLEN, char);
  219.  
  220.     /*
  221.     * Get the name of the user referred to. This scan stops when a separation
  222.     * character is encounterd.
  223.     */
  224.     for(chPtr = file+1, i = 0 ; 
  225.         *chPtr != '\0' && *chPtr != SLASH && *chPtr != ':' ; *chPtr++)
  226.         newfile[i++] = *chPtr;
  227.     newfile[i] = '\0';
  228.  
  229.     if(newfile[0] == '\0')    /* reference to the current user */
  230.     {
  231.         get_user_info();
  232.         sprintf(newfile, "%s%s", user_pwd->pw_dir, chPtr);
  233.     }
  234.     else     /* reference to another user. Get his home directory */
  235.     {
  236.         if((user_info = getpwnam(newfile)) == NULL)
  237.             return;
  238.         sprintf(newfile, "%s%s", user_info->pw_dir, chPtr);
  239.     }
  240.     strcpy(file, newfile);
  241. }
  242.  
  243. /****
  244. * Scan for an environment variable in the given string
  245. ****/
  246. static void
  247. scan_for_env_var(char *file)
  248. {
  249.     char *newfile;
  250.     char *chPtr = NULL, *envPtr = NULL;
  251.     int i;
  252.  
  253.     /* scratch space */
  254.     checked_alloca(newfile, MAXPATHLEN, char);
  255.  
  256.     /*
  257.     * Get the name of the env. var referred to. This scan stops when a 
  258.     * separation character or EOL is encounterd.
  259.     */
  260.     for(chPtr = file+1, i = 0 ; 
  261.         *chPtr != '\0' && *chPtr != SLASH && *chPtr != ':' ; *chPtr++)
  262.         newfile[i++] = *chPtr;
  263.     newfile[i] = '\0';
  264.  
  265.     /* no env. var of this name found, return and don't modify anything */
  266.     if((envPtr = getenv(newfile)) == NULL)
  267.         return;
  268.  
  269.     sprintf(newfile, "%s%s", envPtr, chPtr);
  270.     /* substitute the real value and return the modified string */
  271.     strcpy(file, newfile);
  272. }
  273.  
  274. /****
  275. * Scan for any environment variables or user's home directories
  276. * and replace them with their corresponding value.
  277. * Returns 1 if substitution took place, 0 if not.
  278. ****/
  279. int
  280. scan_for_environment(char *file)
  281. {
  282.     char *chPtr; 
  283.     int changed = 0;
  284.  
  285.     /* first strip out any whitespace */
  286.     stripspaces(file);
  287.  
  288.     for(chPtr = file ; *chPtr != '\0' ; *chPtr++)
  289.     {
  290.         switch(*chPtr)
  291.         {
  292.             case '~':
  293.                 /* home directory of current or other user */
  294.                 scan_for_home(chPtr);
  295.                 changed = 1;
  296.                 break;
  297. #ifdef __MSDOS__    /* msdos environment vars begin with a percent sign */
  298.             case '%':
  299. #else
  300.             case '$':
  301. #endif
  302.                 /* environment variable */
  303.                 scan_for_env_var(chPtr);
  304.                 changed = 1;
  305.                 break;
  306.         }
  307.     }
  308.     return(changed);
  309. }
  310.  
  311. /*****
  312. * make_directory: create a directory dir_to_make
  313. *****/
  314. int
  315. make_directory(char *dir_to_make)
  316. {
  317.     char *temp, *ldir, *chPtr;
  318.     char *curr_dir;
  319.     int r_val;
  320.  
  321.     curr_dir = getcwd(NULL, MAXPATHLEN);    /* getcwd allocates this for us */
  322.  
  323.     checked_alloca(temp, MAXPATHLEN, char);
  324.     checked_alloca(ldir, MAXPATHLEN, char);
  325.  
  326.     /* make a local copy of the given string, we do not want to alter it */
  327.     strncpy(temp, dir_to_make, strlen(dir_to_make)+1);
  328.     /* scan for any environment stuff inside */
  329.     scan_for_environment(temp);
  330.     /* check for a leading directory. If not prepend current path*/
  331.     if(temp[0] != '.' && temp[0] != SLASH)
  332.     {
  333.         sprintf(ldir,"%s%s%s",curr_dir, CHAR_SLASH, temp);
  334.         strncpy(temp,ldir,strlen(ldir)+1);
  335.         strcpy(ldir,"");
  336.     }
  337.     /* test if we can cd to this dir */
  338.     if(((r_val = chdir(temp)) == -1) && errno == ENOENT)
  339.     {
  340.         /* initialise the directory tree, subdirectory by subdirectory. */
  341.         if(temp[0] == SLASH)
  342.             strcpy(ldir, CHAR_SLASH);
  343.         else
  344.             strcpy(ldir,"");
  345.         chPtr = strtok(temp, CHAR_SLASH);
  346.         strcat(ldir, chPtr);
  347.         strcat(ldir, CHAR_SLASH);
  348.         /*
  349.         * recurse through the directories to make. strtok always gives the first
  350.         * part of the directory to create.
  351.         */
  352.         for(chPtr = strtok(NULL, CHAR_SLASH);
  353.             chPtr != NULL; chPtr = strtok(NULL, CHAR_SLASH))
  354.         {
  355.             strcat(ldir, chPtr);
  356.             /* first try to cd to the given dir. */
  357.             if((r_val = chdir(ldir)) == -1 && errno == ENOENT)
  358.             {
  359.                 /* if we fail, create it. */
  360. #ifdef __MSDOS__
  361.                 r_val = mkdir(ldir);
  362. #else
  363.                 r_val = mkdir(ldir, DIR_PERM);
  364. #endif
  365.                 if(r_val)
  366.                 {
  367.                     chdir(curr_dir);
  368.                     free(curr_dir);
  369.                     return(r_val);
  370.                 }
  371.             }
  372.             strcat(ldir, CHAR_SLASH);
  373.         }
  374.     }
  375.     else
  376.     /* directory already exists */
  377.     {
  378.         chdir(curr_dir);
  379.         free(curr_dir);
  380.         return(0); 
  381.     }
  382.     chdir(curr_dir);
  383.     free(curr_dir);
  384.     printf("Created directory %s\n", dir_to_make);
  385.     return(r_val);
  386. }
  387.  
  388. /****
  389. * string_to_file: save the given string to a given file name
  390. * In:
  391. *    text: text to save to file
  392. *    filename: file to save to
  393. * Returns:
  394. *    0 on success, -1 on failure and errno is set 
  395. ****/
  396. int
  397. string_to_file(char *text, char *filename)
  398. {
  399.     int len;
  400.     FILE *fp;
  401.  
  402.     /* scan for any environment variables in here */
  403.     scan_for_environment(filename);
  404.  
  405.     /* try to open a file with the given name */
  406. #ifndef __MSDOS__
  407.     if ((fp = fopen(filename,"w")) == NULL) 
  408. #else
  409.     if ((fp = fopen(filename,"wb")) == NULL) 
  410. #endif
  411.         return(-1);
  412.     /* add a newline to the text if it isn't already there */
  413.     len = strlen(text); 
  414.     if(text[len-1] != '\n')
  415.         text[len++]= '\n'; 
  416.     /* flush the contents of text to the given file */
  417.     fwrite(text, sizeof(char), len, fp);
  418.     /* close the file */
  419.     if (fclose(fp))
  420.         return(-1);
  421.     return(0);
  422. }
  423.  
  424. /****
  425. * Check if file exists by statting it.
  426. * returns 0 on failure, size of file on success.
  427. * This function does not test if the file is writable.
  428. ****/
  429. unsigned long
  430. check_if_file_exists(char *file)
  431. {
  432.     struct stat buf;
  433.     if(stat(file, &buf))
  434.         return(0);
  435.     return((unsigned long)buf.st_size);
  436. }
  437.