home *** CD-ROM | disk | FTP | other *** search
/ ftp.uv.es / 2014.11.ftp.uv.es.tar / ftp.uv.es / pub / unix / elm-2.4-pl20.tar.Z / elm-2.4-pl20.tar / lib / opt_utils.c < prev    next >
C/C++ Source or Header  |  1993-01-12  |  10KB  |  481 lines
  1.  
  2. static char rcsid[] = "@(#)$Id: opt_utils.c,v 5.4 1992/12/12 01:29:26 syd Exp $";
  3.  
  4. /*******************************************************************************
  5.  *  The Elm Mail System  -  $Revision: 5.4 $   $State: Exp $
  6.  *
  7.  *            Copyright (c) 1988-1992 USENET Community Trust
  8.  *            Copyright (c) 1986,1987 Dave Taylor
  9.  *******************************************************************************
  10.  * Bug reports, patches, comments, suggestions should be sent to:
  11.  *
  12.  *    Syd Weinstein, Elm Coordinator
  13.  *    elm@DSI.COM            dsinc!elm
  14.  *
  15.  *******************************************************************************
  16.  * $Log: opt_utils.c,v $
  17.  * Revision 5.4  1992/12/12  01:29:26  syd
  18.  * Fix double inclusion of sys/types.h
  19.  * From: Tom Moore <tmoore@wnas.DaytonOH.NCR.COM>
  20.  *
  21.  * Revision 5.3  1992/10/30  21:49:38  syd
  22.  * Add init of buf
  23.  * From: Syd via request from hessmann@unipas.fmi.uni-passau.de (Georg Hessmann)
  24.  *
  25.  * Revision 5.2  1992/10/24  13:06:23  syd
  26.  * make getdomainname optional
  27.  * From: Syd
  28.  *
  29.  * Revision 5.1  1992/10/03  22:41:36  syd
  30.  * Initial checkin as of 2.4 Release at PL0
  31.  *
  32.  *
  33.  ******************************************************************************/
  34.  
  35. /** This file contains routines that might be needed for the various
  36.      machines that the mailer can run on.  Please check the Makefile
  37.      for more help and/or information. 
  38.  
  39. **/
  40.  
  41. #include "headers.h"
  42. #include "s_error.h"
  43. #include <ctype.h>
  44.  
  45. #ifdef PWDINSYS
  46. #  include <sys/pwd.h>
  47. #else
  48. #  include <pwd.h>
  49. #endif
  50.  
  51. #ifdef BSD
  52. #undef tolower
  53. #undef toupper
  54. #endif
  55.  
  56. #ifndef GETHOSTNAME
  57. # ifdef DOUNAME
  58. #  include <sys/utsname.h>
  59. # endif
  60. #endif
  61.  
  62. char *index();
  63.  
  64. #ifndef GETHOSTNAME
  65.  
  66. gethostname(cur_hostname,size) /* get name of current host */
  67. char *cur_hostname;
  68. int size;
  69. {
  70.     /** Return the name of the current host machine. **/
  71.  
  72. #if (defined(XENIX) || defined(M_UNIX)) & !defined(DOUNAME)
  73.     char    buf[32];
  74.     FILE    *fp;
  75.     char    *p;
  76.  
  77.     buf[0] = '\0';
  78.  
  79.     if ((fp = fopen("/etc/systemid", "r")) != 0) {
  80.       fgets(buf, sizeof(buf) - 1, fp);
  81.       fclose(fp);
  82.       if ((p = index(buf, '\n')) != NULL)
  83.         *p = '\0';
  84.       (void) strncpy(cur_hostname, buf, size - 1);
  85.       cur_hostname[size - 1] = '\0';
  86.       return 0;
  87.     }
  88.  
  89. #else   /* neither XENIX nor SCO UNIX */
  90.  
  91. #ifdef DOUNAME
  92.     /** This routine compliments of Scott McGregor at the HP
  93.         Corporate Computing Center **/
  94.      
  95.     int uname();
  96.     struct utsname name;
  97.  
  98.     (void) uname(&name);
  99.     (void) strncpy(cur_hostname,name.nodename,size-1);
  100. #else
  101.     (void) strncpy(cur_hostname, HOSTNAME, size-1);
  102. #endif    /* DOUNAME */
  103.  
  104.     cur_hostname[size - 1] = '\0';
  105.     return 0;
  106.  
  107. #endif  /* XENIX or SCO UNIX */
  108. }
  109.  
  110. #endif  /* GETHOSTNAME */
  111.  
  112.  
  113. gethostdomain(hostdom, size)    /* get domain of current host */
  114. char *hostdom;
  115. int size;
  116. {
  117.     char    buf[64];
  118.     FILE    *fp;
  119.     char    *p;
  120.  
  121.     if (size < 2)
  122.       return -1;
  123.  
  124.     buf[0] = '\0';
  125.  
  126.     if ((fp = fopen(hostdomfile, "r")) != 0) {
  127.       fgets(buf, sizeof(buf) - 1, fp);
  128.       fclose(fp);
  129.       if ((p = index(buf, '\n')) != NULL)
  130.         *p = '\0';
  131.     }
  132.     else {
  133. #ifdef USEGETDOMAINNAME
  134.       if (getdomainname(buf, sizeof(buf)) != 0)
  135. #endif
  136.         strncpy(buf, DEFAULT_DOMAIN, sizeof(buf) - 1);
  137.     }
  138.     if (buf[0] != '\0' && buf[0] != '.') {
  139.       *hostdom++ = '.';
  140.       --size;
  141.     }
  142.     (void) strncpy(hostdom, buf, size - 1);
  143.     hostdom[size - 1] = '\0';
  144.  
  145.     return 0;
  146. }
  147.  
  148.  
  149. #ifndef HAS_CUSERID
  150.  
  151. char *cuserid(uname)
  152.      char *uname;
  153. {
  154.     /** Added for compatibility with Bell systems, this is the last-ditch
  155.         attempt to get the users login name, after getlogin() fails.  It
  156.         instantiates "uname" to the name of the user...(it also tries
  157.         to use "getlogin" again, just for luck)
  158.     **/
  159.     /** This wasn't really compatible.  According to our man page, 
  160.      ** It was inconsistent.  If the parameter is NULL then you return
  161.      ** the name in a static area.  Else the ptr is supposed to be a
  162.      ** pointer to l_cuserid bytes of memory [probally 9 bytes]...
  163.      ** It's not mention what it should return if you copy the name
  164.      ** into the array, so I chose NULL.
  165.      **                     Sept 20, 1988
  166.      **                    **WJL**
  167.      **/
  168.  
  169.   struct passwd *password_entry;
  170. #ifndef _POSIX_SOURCE
  171.   struct passwd *getpwuid();
  172. #endif
  173.   char   *name, *getlogin();
  174.   static char buf[10];
  175.   register returnonly = 0;
  176.   
  177.   if (uname == NULL) ++returnonly;
  178.   
  179.   if ((name = getlogin()) != NULL) {
  180.     if (returnonly) {
  181.       return(name);
  182.     } else {
  183.       strcpy(uname, name);
  184.       return name;
  185.     }
  186.   } 
  187.   else 
  188.     if (( password_entry = getpwuid(getuid())) != NULL) 
  189.       {
  190.     if (returnonly) 
  191.       {
  192.         return(password_entry->pw_name);
  193.       }
  194.     else 
  195.       {
  196.         strcpy(uname, password_entry->pw_name);
  197.         return name;
  198.       }
  199.       } 
  200.     else 
  201.       {
  202.     return NULL;
  203.       }
  204. }
  205.  
  206. #endif
  207.  
  208. #if defined(BSD) && !defined(_POSIX_SOURCE)
  209.  
  210. /** some supplementary string functions for Berkeley Unix systems **/
  211.  
  212. int
  213. tolower(ch)
  214. int ch;
  215. {
  216.     /** This should be a macro call, but if you use this as a macro
  217.         calls to 'tolower' where the argument is a function call will
  218.         cause the function to be called TWICE which is obviously the
  219.         wrong behaviour.  On the other hand, to just blindly translate
  220.         assuming the character is always uppercase can cause BIG
  221.         problems, so...
  222.     **/
  223.  
  224.     return ( isupper(ch) ? ch - 'A' + 'a' : ch );
  225. }
  226.  
  227. int
  228. toupper(ch)
  229. int ch;
  230. {
  231.     /** see comment for above routine - tolower() **/
  232.  
  233.     return ( islower(ch) ? ch - 'a' + 'A' : ch );
  234. }
  235.  
  236. #endif
  237.  
  238. #ifndef STRTOK
  239.  
  240. char *strtok(source, keys)
  241. char *source, *keys;
  242. {
  243.     /** This function returns a pointer to the next word in source
  244.         with the string considered broken up at the characters 
  245.         contained in 'keys'.  Source should be a character pointer
  246.         when this routine is first called, then NULL subsequently.
  247.         When strtok has exhausted the source string, it will 
  248.         return NULL as the next word. 
  249.  
  250.         WARNING: This routine will DESTROY the string pointed to
  251.         by 'source' when first invoked.  If you want to keep the
  252.         string, make a copy before using this routine!!
  253.      **/
  254.  
  255.     register int  last_ch;
  256.     static   char *sourceptr;
  257.          char *return_value;
  258.  
  259.     if (source != NULL)
  260.       sourceptr = source;
  261.     
  262.     if (*sourceptr == '\0') 
  263.       return(NULL);        /* we hit end-of-string last time!? */
  264.  
  265.     sourceptr += strspn(sourceptr, keys);    /* skip leading crap */
  266.     
  267.     if (*sourceptr == '\0') 
  268.       return(NULL);        /* we've hit end-of-string */
  269.  
  270.     last_ch = strcspn(sourceptr, keys);    /* end of good stuff */
  271.  
  272.     return_value = sourceptr;        /* and get the ret   */
  273.  
  274.     sourceptr += last_ch;            /* ...value          */
  275.  
  276.     if (*sourceptr != '\0')        /* don't forget if we're at END! */
  277.       sourceptr++;               /* and skipping for next time */
  278.  
  279.     return_value[last_ch] = '\0';        /* ..ending right    */
  280.     
  281.     return((char *) return_value);        /* and we're outta here! */
  282. }
  283.  
  284. #endif
  285.  
  286.  
  287. #ifndef STRPBRK
  288.  
  289. char *strpbrk(source, keys)
  290. char *source, *keys;
  291. {
  292.     /** Returns a pointer to the first character of source that is any
  293.         of the specified keys, or NULL if none of the keys are present
  294.         in the source string. 
  295.     **/
  296.  
  297.     register char *s, *k;
  298.  
  299.     for (s = source; *s != '\0'; s++) {
  300.       for (k = keys; *k; k++)
  301.         if (*k == *s)
  302.           return(s);
  303.     }
  304.     
  305.     return(NULL);
  306. }
  307.  
  308. #endif
  309.  
  310. #ifndef STRSPN
  311.  
  312. strspn(source, keys)
  313. char *source, *keys;
  314. {
  315.     /** This function returns the length of the substring of
  316.         'source' (starting at zero) that consists ENTIRELY of
  317.         characters from 'keys'.  This is used to skip over a
  318.         defined set of characters with parsing, usually. 
  319.     **/
  320.  
  321.     register int loc = 0, key_index = 0;
  322.  
  323.     while (source[loc] != '\0') {
  324.       key_index = 0;
  325.       while (keys[key_index] != source[loc])
  326.         if (keys[key_index++] == '\0')
  327.           return(loc);
  328.       loc++;
  329.     }
  330.  
  331.     return(loc);
  332. }
  333.  
  334. #endif
  335.  
  336. #ifndef STRCSPN
  337.  
  338. strcspn(source, keys)
  339. char *source, *keys;
  340. {
  341.     /** This function returns the length of the substring of
  342.         'source' (starting at zero) that consists entirely of
  343.         characters NOT from 'keys'.  This is used to skip to a
  344.         defined set of characters with parsing, usually. 
  345.         NOTE that this is the opposite of strspn() above
  346.     **/
  347.  
  348.     register int loc = 0, key_index = 0;
  349.  
  350.     while (source[loc] != '\0') {
  351.       key_index = 0;
  352.       while (keys[key_index] != '\0')
  353.         if (keys[key_index++] == source[loc])
  354.           return(loc);
  355.       loc++;
  356.     }
  357.  
  358.     return(loc);
  359. }
  360.  
  361. #endif
  362.  
  363. #ifndef TEMPNAM
  364. /* and a tempnam for temporary files */
  365. static int cnt = 0;
  366.  
  367. char *tempnam( dir, pfx)
  368.  char *dir, *pfx;
  369. {
  370.     char space[SLEN];
  371.     char *newspace;
  372.  
  373.     if (dir == NULL) {
  374.         dir = "/usr/tmp";
  375.     } else if (*dir == '\0') {
  376.         dir = "/usr/tmp";
  377.     }
  378.     
  379.     if (pfx == NULL) {
  380.         pfx = "";
  381.     }
  382.  
  383.     sprintf(space, "%s%s%d.%d", dir, pfx, getpid(), cnt);
  384.     cnt++;
  385.     
  386.     newspace = malloc(strlen(space) + 1);
  387.     if (newspace != NULL) {
  388.         strcpy(newspace, space);
  389.     }
  390.     return newspace;
  391. }
  392.  
  393. #endif
  394.  
  395. #ifndef GETOPT
  396.  
  397. /*LINTLIBRARY*/
  398. #define NULL    0
  399. #define EOF    (-1)
  400. #define ERR(s, c)    if(opterr){\
  401.     extern int strlen(), write();\
  402.     char errbuf[2];\
  403.     errbuf[0] = c; errbuf[1] = '\n';\
  404.     (void) write(2, argv[0], (unsigned)strlen(argv[0]));\
  405.     (void) write(2, s, (unsigned)strlen(s));\
  406.     (void) write(2, errbuf, 2);}
  407.  
  408. extern int strcmp();
  409.  
  410. int    opterr = 1;
  411. int    optind = 1;
  412. int    optopt;
  413. char    *optarg;
  414.  
  415. int
  416. getopt(argc, argv, opts)
  417. int    argc;
  418. char    **argv, *opts;
  419. {
  420.     static int sp = 1;
  421.     register int c;
  422.     register char *cp;
  423.  
  424.     if(sp == 1)
  425.         if(optind >= argc ||
  426.            argv[optind][0] != '-' || argv[optind][1] == '\0')
  427.             return(EOF);
  428.         else if(strcmp(argv[optind], "--") == NULL) {
  429.             optind++;
  430.             return(EOF);
  431.         }
  432.     optopt = c = argv[optind][sp];
  433.     if(c == ':' || (cp=index(opts, c)) == NULL) {
  434.         ERR(": illegal option -- ", c);
  435.         if(argv[optind][++sp] == '\0') {
  436.             optind++;
  437.             sp = 1;
  438.         }
  439.         return('?');
  440.     }
  441.     if(*++cp == ':') {
  442.         if(argv[optind][sp+1] != '\0')
  443.             optarg = &argv[optind++][sp+1];
  444.         else if(++optind >= argc) {
  445.             cp = catgets(elm_msg_cat, ErrorSet, ErrorGetoptReq,
  446.                 ": option requires an argument -- ");
  447.             ERR(cp, c);
  448.             sp = 1;
  449.             return('?');
  450.         } else
  451.             optarg = argv[optind++];
  452.         sp = 1;
  453.     } else {
  454.         if(argv[optind][++sp] == '\0') {
  455.             sp = 1;
  456.             optind++;
  457.         }
  458.         optarg = NULL;
  459.     }
  460.     return(c);
  461. }
  462.  
  463. #endif
  464.  
  465. #ifndef RENAME
  466. int rename(tmpfname, fname)
  467. #ifdef ANSI_C
  468. const
  469. #endif
  470.    char *tmpfname, *fname;
  471. {
  472.     int status;
  473.  
  474.     (void) unlink(fname);
  475.     if ((status = link(tmpfname, fname)) != 0)
  476.         return(status);
  477.     (void) unlink(tmpfname);
  478.     return(0);
  479. }
  480. #endif
  481.