开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 网络编程 > 查看源码
env_ami.c
资源名称：imap-4.7.tar.Z　[点击查看]
上传用户：ycwykj01
上传日期：2007-01-04
资源大小：1819k
文件大小：33k
源码类别：

网络编程

开发平台：

Unix_Linux

env_ami.c：源码内容
  1. /*
  2.  * Program: Amiga environment routines
  3.  *
  4.  * Author: Mark Crispin
  5.  * Networks and Distributed Computing
  6.  * Computing & Communications
  7.  * University of Washington
  8.  * Administration Building, AG-44
  9.  * Seattle, WA  98195
  10.  * Internet: MRC@CAC.Washington.EDU
  11.  *
  12.  * Date: 1 August 1988
  13.  * Last Edited: 1 November 1999
  14.  *
  15.  * Copyright 1999 by the University of Washington
  16.  *
  17.  *  Permission to use, copy, modify, and distribute this software and its
  18.  * documentation for any purpose and without fee is hereby granted, provided
  19.  * that the above copyright notice appears in all copies and that both the
  20.  * above copyright notice and this permission notice appear in supporting
  21.  * documentation, and that the name of the University of Washington not be
  22.  * used in advertising or publicity pertaining to distribution of the software
  23.  * without specific, written prior permission.  This software is made available
  24.  * "as is", and
  25.  * THE UNIVERSITY OF WASHINGTON DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED,
  26.  * WITH REGARD TO THIS SOFTWARE, INCLUDING WITHOUT LIMITATION ALL IMPLIED
  27.  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, AND IN
  28.  * NO EVENT SHALL THE UNIVERSITY OF WASHINGTON BE LIABLE FOR ANY SPECIAL,
  29.  * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  30.  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, TORT
  31.  * (INCLUDING NEGLIGENCE) OR STRICT LIABILITY, ARISING OUT OF OR IN CONNECTION
  32.  * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  33.  *
  34.  */
  36. #include <signal.h>
  37. #include <sys/wait.h>
  38. #include "write.c" /* include safe writing routines */
  40. /* Get all authenticators */
  42. #include "auths.c"
  44. /* c-client environment parameters */
  46. static const char *anonymous_user = "nobody";
  47. static const char *unlogged_user = "root";
  49. static char *myUserName = NIL; /* user name */
  50. static char *myHomeDir = NIL; /* home directory name */
  51. static char *myLocalHost = NIL; /* local host name */
  52. static char *myNewsrc = NIL; /* newsrc file name */
  53. static char *sysInbox = NIL; /* system inbox name */
  54. static char *newsActive = NIL; /* news active file */
  55. static char *newsSpool = NIL; /* news spool */
  56. /* anonymous home directory */
  57. static char *anonymousHome = NIL;
  58. static char *ftpHome = NIL; /* ftp export home directory */
  59. static char *publicHome = NIL; /* public home directory */
  60. static char *sharedHome = NIL; /* shared home directory */
  61. static short anonymous = NIL; /* is anonymous */
  62. static short has_no_life = NIL; /* is a cretin with no life */
  63. static long list_max_level = 20;/* maximum level of list recursion */
  64. /* default file protection */
  65. static long mbx_protection = 0600;
  66. /* default directory protection */
  67. static long dir_protection = 0700;
  68. /* default lock file protection */
  69. static long lock_protection = 0666;
  70. /* default ftp file protection */
  71. static long ftp_protection = 0644;
  72. /* default public file protection */
  73. static long public_protection = 0666;
  74. /* default shared file protection */
  75. static long shared_protection = 0660;
  76. static long locktimeout = 5; /* default lock timeout */
  77. /* warning on EACCES errors on .lock files */
  78. static long lockEaccesError = T;
  79. /* default prototypes */
  80. static MAILSTREAM *createProto = NIL;
  81. static MAILSTREAM *appendProto = NIL;
  82. /* default user flags */
  83. static char *userFlags[NUSERFLAGS] = {NIL};
  84. static NAMESPACE *nslist[3]; /* namespace list */
  85. static int logtry = 3; /* number of server login tries */
  86. /* block notification */
  87. static blocknotify_t mailblocknotify = mm_blocknotify;
  89. /* Amiga namespaces */
  91. /* personal mh namespace */
  92. static NAMESPACE nsmhf = {"#mh/",'/',NIL,NIL};
  93. static NAMESPACE nsmh = {"#mhinbox",NIL,NIL,&nsmhf};
  94. /* home namespace */
  95. static NAMESPACE nshome = {"",'/',NIL,&nsmh};
  96. /* Amiga other user namespace */
  97. static NAMESPACE nsamigaother = {"~",'/',NIL,NIL};
  98. /* public (anonymous OK) namespace */
  99. static NAMESPACE nspublic = {"#public/",'/',NIL,NIL};
  100. /* netnews namespace */
  101. static NAMESPACE nsnews = {"#news.",'.',NIL,&nspublic};
  102. /* FTP export namespace */
  103. static NAMESPACE nsftp = {"#ftp/",'/',NIL,&nsnews};
  104. /* shared (no anonymous) namespace */
  105. static NAMESPACE nsshared = {"#shared/",'/',NIL,&nsftp};
  107. /* Environment manipulate parameters
  108.  * Accepts: function code
  109.  *     function-dependent value
  110.  * Returns: function-dependent return value
  111.  */
  113. void *env_parameters (long function,void *value)
  114. {
  115.   switch ((int) function) {
  116.   case SET_NAMESPACE:
  117.     fatal ("SET_NAMESPACE not permitted");
  118.   case GET_NAMESPACE:
  119.     value = (void *) nslist;
  120.     break;
  121.   case SET_USERNAME:
  122.     if (myUserName) fs_give ((void **) &myUserName);
  123.     myUserName = cpystr ((char *) value);
  124.     break;
  125.   case GET_USERNAME:
  126.     value = (void *) myUserName;
  127.     break;
  128.   case SET_HOMEDIR:
  129.     if (myHomeDir) fs_give ((void **) &myHomeDir);
  130.     myHomeDir = cpystr ((char *) value);
  131.     break;
  132.   case GET_HOMEDIR:
  133.     value = (void *) myHomeDir;
  134.     break;
  135.   case SET_LOCALHOST:
  136.     if (myLocalHost) fs_give ((void **) &myLocalHost);
  137.     myLocalHost = cpystr ((char *) value);
  138.     break;
  139.   case GET_LOCALHOST:
  140.     value = (void *) myLocalHost;
  141.     break;
  142.   case SET_NEWSRC:
  143.     if (myNewsrc) fs_give ((void **) &myNewsrc);
  144.     myNewsrc = cpystr ((char *) value);
  145.     break;
  146.   case GET_NEWSRC:
  147.     value = (void *) myNewsrc;
  148.     break;
  149.   case SET_NEWSACTIVE:
  150.     if (newsActive) fs_give ((void **) &newsActive);
  151.     newsActive = cpystr ((char *) value);
  152.     break;
  153.   case GET_NEWSACTIVE:
  154.     value = (void *) newsActive;
  155.     break;
  157.   case SET_NEWSSPOOL:
  158.     if (newsSpool) fs_give ((void **) &newsSpool);
  159.     newsSpool = cpystr ((char *) value);
  160.     break;
  161.   case GET_NEWSSPOOL:
  162.     value = (void *) newsSpool;
  163.     break;
  164.   case SET_ANONYMOUSHOME:
  165.     if (anonymousHome) fs_give ((void **) &anonymousHome);
  166.     anonymousHome = cpystr ((char *) value);
  167.     break;
  168.   case GET_ANONYMOUSHOME:
  169.     value = (void *) anonymousHome;
  170.     break;
  171.   case SET_FTPHOME:
  172.     if (ftpHome) fs_give ((void **) &ftpHome);
  173.     ftpHome = cpystr ((char *) value);
  174.     break;
  175.   case GET_FTPHOME:
  176.     value = (void *) ftpHome;
  177.     break;
  178.   case SET_PUBLICHOME:
  179.     if (publicHome) fs_give ((void **) &publicHome);
  180.     publicHome = cpystr ((char *) value);
  181.     break;
  182.   case GET_PUBLICHOME:
  183.     value = (void *) publicHome;
  184.     break;
  185.   case SET_SHAREDHOME:
  186.     if (sharedHome) fs_give ((void **) &sharedHome);
  187.     sharedHome = cpystr ((char *) value);
  188.     break;
  189.   case GET_SHAREDHOME:
  190.     value = (void *) sharedHome;
  191.     break;
  192.   case SET_SYSINBOX:
  193.     if (sysInbox) fs_give ((void **) &sysInbox);
  194.     sysInbox = cpystr ((char *) value);
  195.     break;
  196.   case GET_SYSINBOX:
  197.     value = (void *) sysInbox;
  198.     break;
  199.   case SET_LISTMAXLEVEL:
  200.     list_max_level = (long) value;
  201.     break;
  202.   case GET_LISTMAXLEVEL:
  203.     value = (void *) list_max_level;
  204.     break;
  206.   case SET_MBXPROTECTION:
  207.     mbx_protection = (long) value;
  208.     break;
  209.   case GET_MBXPROTECTION:
  210.     value = (void *) mbx_protection;
  211.     break;
  212.   case SET_DIRPROTECTION:
  213.     dir_protection = (long) value;
  214.     break;
  215.   case GET_DIRPROTECTION:
  216.     value = (void *) dir_protection;
  217.     break;
  218.   case SET_LOCKPROTECTION:
  219.     lock_protection = (long) value;
  220.     break;
  221.   case GET_LOCKPROTECTION:
  222.     value = (void *) lock_protection;
  223.     break;
  224.   case SET_FTPPROTECTION:
  225.     ftp_protection = (long) value;
  226.     break;
  227.   case GET_FTPPROTECTION:
  228.     value = (void *) ftp_protection;
  229.     break;
  230.   case SET_PUBLICPROTECTION:
  231.     public_protection = (long) value;
  232.     break;
  233.   case GET_PUBLICPROTECTION:
  234.     value = (void *) public_protection;
  235.     break;
  236.   case SET_SHAREDPROTECTION:
  237.     shared_protection = (long) value;
  238.     break;
  239.   case GET_SHAREDPROTECTION:
  240.     value = (void *) shared_protection;
  241.     break;
  242.   case SET_LOCKTIMEOUT:
  243.     locktimeout = (long) value;
  244.     break;
  245.   case GET_LOCKTIMEOUT:
  246.     value = (void *) locktimeout;
  247.     break;
  248.   case SET_LOCKEACCESERROR:
  249.     lockEaccesError = (long) value;
  250.     break;
  251.   case GET_LOCKEACCESERROR:
  252.     value = (void *) lockEaccesError;
  253.     break;
  255.   case SET_USERHASNOLIFE:
  256.     has_no_life = value ? T : NIL;
  257.     break;
  258.   case GET_USERHASNOLIFE:
  259.     value = (void *) (has_no_life ? T : NIL);
  260.     break;
  261.   case SET_BLOCKNOTIFY:
  262.     mailblocknotify = (blocknotify_t) value;
  263.   case GET_BLOCKNOTIFY:
  264.     value = (void *) mailblocknotify;
  265.     break;
  266.   default:
  267.     value = NIL; /* error case */
  268.     break;
  269.   }
  270.   return value;
  271. }
  273. /* Write current time
  274.  * Accepts: destination string
  275.  *     optional format of day-of-week prefix
  276.  *     format of date and time
  277.  *     flag whether to append symbolic timezone
  278.  */
  280. static void do_date (char *date,char *prefix,char *fmt,int suffix)
  281. {
  282.   time_t tn = time (0);
  283.   struct tm *t = gmtime (&tn);
  284.   int zone = t->tm_hour * 60 + t->tm_min;
  285.   int julian = t->tm_yday;
  286.   t = localtime (&tn); /* get local time now */
  287. /* minus UTC minutes since midnight */
  288.   zone = t->tm_hour * 60 + t->tm_min - zone;
  289.   /* julian can be one of:
  290.    *  36x  local time is December 31, UTC is January 1, offset -24 hours
  291.    *    1  local time is 1 day ahead of UTC, offset +24 hours
  292.    *    0  local time is same day as UTC, no offset
  293.    *   -1  local time is 1 day behind UTC, offset -24 hours
  294.    * -36x  local time is January 1, UTC is December 31, offset +24 hours
  295.    */
  296.   if (julian = t->tm_yday -julian)
  297.     zone += ((julian < 0) == (abs (julian) == 1)) ? -24*60 : 24*60;
  298.   if (prefix) { /* want day of week? */
  299.     sprintf (date,prefix,days[t->tm_wday]);
  300.     date += strlen (date); /* make next sprintf append */
  301.   }
  302. /* output the date */
  303.   sprintf (date,fmt,t->tm_mday,months[t->tm_mon],t->tm_year+1900,
  304.    t->tm_hour,t->tm_min,t->tm_sec,zone/60,abs (zone) % 60);
  305. /* append timezone suffix if desired */
  306.   if (suffix) rfc822_timezone (date,(void *) t);
  307. }
  309. /* Write current time in RFC 822 format
  310.  * Accepts: destination string
  311.  */
  313. void rfc822_date (char *date)
  314. {
  315.   do_date (date,"%s, ","%d %s %d %02d:%02d:%02d %+03d%02d",T);
  316. }
  319. /* Write current time in fixed-width RFC 822 format
  320.  * Accepts: destination string
  321.  */
  323. void rfc822_fixed_date (char *date)
  324. {
  325.   do_date (date,NIL,"%02d %s %4d %02d:%02d:%02d %+03d%02d",NIL);
  326. }
  329. /* Write current time in internal format
  330.  * Accepts: destination string
  331.  */
  333. void internal_date (char *date)
  334. {
  335.   do_date (date,NIL,"%02d-%s-%d %02d:%02d:%02d %+03d%02d",NIL);
  336. }
  338. /* Initialize server
  339.  * Accepts: server name for syslog or NIL
  340.  *     /etc/services service name or NIL
  341.  *     alternate /etc/services service name or NIL
  342.  *     SASL service name or NIL
  343.  *     clock interrupt handler
  344.  *     kiss-of-death interrupt handler
  345.  *     hangup interrupt handler
  346.  *     termination interrupt handler
  347.  */
  349. void server_init (char *server,char *service,char *altservice,char *sasl,
  350.   void *clkint,void *kodint,void *hupint,void *trmint)
  351. {
  352.   long port;
  353.   struct servent *sv;
  354.   struct sockaddr_in sin;
  355.   int sinlen = sizeof (struct sockaddr_in);
  356.   /* Don't use tcp_clienthost() since reverse DNS problems may slow down the
  357.    * greeting message and cause the client to time out.
  358.    */
  359.   char *client = getpeername (0,(struct sockaddr *) &sin,(void *) &sinlen) ?
  360.     "UNKNOWN" : inet_ntoa (sin.sin_addr);
  361. /* set server name in syslog */
  362.   if (server) openlog (server,LOG_PID,LOG_MAIL);
  363.   if (service && altservice && ((port = tcp_serverport ()) >= 0)) {
  364.     if ((sv = getservbyname (service,"tcp")) && (port == ntohs (sv->s_port)))
  365.       syslog (LOG_DEBUG,"%s service init from %s",service,client);
  366.     else if ((sv = getservbyname (altservice,"tcp")) &&
  367.      (port == ntohs (sv->s_port)))
  368.       syslog (LOG_DEBUG,"%s alternative service init from %s",
  369.       altservice,client);
  370.     else syslog (LOG_DEBUG,"port %ld service init from %s",port,client);
  371.   }
  372. /* set SASL name */
  373.   if (sasl) mail_parameters (NIL,SET_SERVICENAME,(void *) sasl);
  374.   signal (SIGALRM,clkint); /* prepare for clock interrupt */
  375.   signal (SIGUSR2,kodint); /* prepare for Kiss Of Death */
  376.   signal (SIGHUP,hupint); /* prepare for hangup */
  377.   signal (SIGTERM,trmint); /* prepare for termination */
  378. }
  380. /* Wait for stdin input
  381.  * Accepts: timeout in seconds
  382.  * Returns: T if have input on stdin, else NIL
  383.  */
  385. long server_input_wait (long seconds)
  386. {
  387.   fd_set rfd,efd;
  388.   struct timeval tmo;
  389.   FD_ZERO (&rfd);
  390.   FD_ZERO (&efd);
  391.   FD_SET (0,&rfd);
  392.   FD_SET (0,&efd);
  393.   tmo.tv_sec = seconds; tmo.tv_usec = 0;
  394.   return select (1,&rfd,0,&efd,&tmo) ? LONGT : NIL;
  395. }
  397. /* Server log in
  398.  * Accepts: user name string
  399.  *     password string
  400.  *     argument count
  401.  *     argument vector
  402.  * Returns: T if password validated, NIL otherwise
  403.  */
  405. long server_login (char *user,char *pwd,int argc,char *argv[])
  406. {
  407.   char *s,usr[MAILTMPLEN];
  408.   struct passwd *pw;
  409. /* cretins still haven't given up */
  410.   if (strlen (user) >= MAILTMPLEN)
  411.     syslog (LOG_ALERT|LOG_AUTH,"System break-in attempt, host=%.80s",
  412.     tcp_clienthost ());
  413. /* validate with case-independence */
  414.   else if ((logtry > 0) && ((pw = getpwnam (strcpy (usr,user))) ||
  415.     (pw = getpwnam (lcase (usr))))) {
  416.     if (auth_md5.server) { /* if using CRAM-MD5 authentication */
  417.       char *p = auth_md5_pwd (pw->pw_name);
  418.       if (p) { /* verify password */
  419. if (strcmp (p,pwd) && strcmp (p,pwd+1)) pw = NIL;
  420. memset (p,0,strlen (p));/* erase sensitive information */
  421. fs_give ((void **) &p); /* flush erased password */
  422. if (pw) return pw_login (pw,pw->pw_name,pw->pw_dir,argc,argv);
  423.       }
  424.       else syslog (LOG_ERR|LOG_AUTH,
  425.    "Login failed: %s has no CRAM-MD5 password, host=%.80s",
  426.    pw->pw_name,tcp_clienthost ());
  427.     }
  428. /* ordinary password authentication */
  429.     else if ((pw = checkpw (pw,pwd,argc,argv)) ||
  430.      ((*pwd == ' ') && (pw = checkpw (getpwnam(usr),pwd+1,argc,argv))))
  431.       return pw_login (pw,pw->pw_name,pw->pw_dir,argc,argv);
  432.   }
  433.   s = (logtry-- > 0) ? "Login failure" : "Excessive login attempts";
  434. /* note the failure in the syslog */
  435.   syslog (LOG_INFO,"%s user=%.80s host=%.80s",s,user,tcp_clienthost ());
  436.   sleep (3); /* slow down possible cracker */
  437.   return NIL;
  438. }
  440. /* Authenticated server log in
  441.  * Accepts: user name string
  442.  *     argument count
  443.  *     argument vector
  444.  * Returns: T if password validated, NIL otherwise
  445.  */
  447. long authserver_login (char *user,int argc,char *argv[])
  448. {
  449.   struct passwd *pw = getpwnam (user);
  450.   return pw ? pw_login (pw,pw->pw_name,pw->pw_dir,argc,argv) : NIL;
  451. }
  454. /* Log in as anonymous daemon
  455.  * Accepts: argument count
  456.  *     argument vector
  457.  * Returns: T if successful, NIL if error
  458.  */
  460. long anonymous_login (int argc,char *argv[])
  461. {
  462.   struct passwd *pw = getpwnam ((char *) anonymous_user);
  463. /* log in Mr. A. N. Onymous */
  464.   return pw ? pw_login (pw,NIL,NIL,argc,argv) : NIL;
  465. }
  468. /* Finish log in and environment initialization
  469.  * Accepts: passwd struct for loginpw()
  470.  *     user name (NIL for anonymous)
  471.  *     home directory (NIL for anonymous)
  472.  *     argument count
  473.  *     argument vector
  474.  * Returns: T if successful, NIL if error
  475.  */
  477. long pw_login (struct passwd *pw,char *user,char *home,int argc,char *argv[])
  478. {
  479.   long ret = NIL;
  480.   char *u = user ? cpystr (user) : NIL;
  481.   char *h = home ? cpystr (home) : NIL;
  482.   if (pw->pw_uid && ((pw->pw_uid == geteuid ()) || loginpw (pw,argc,argv)) &&
  483.       (ret = env_init (u,h))) chdir (myhomedir ());
  484.   if (h) fs_give ((void **) &h);/* flush temporary home directory */
  485.   if (u) fs_give ((void **) &u);/* flush temporary user name */
  486.   return ret; /* return status */
  487. }
  489. /* Initialize environment
  490.  * Accepts: user name
  491.  *     home directory name
  492.  * Returns: T, always
  493.  */
  495. long env_init (char *user,char *home)
  496. {
  497.   extern MAILSTREAM CREATEPROTO;
  498.   extern MAILSTREAM EMPTYPROTO;
  499.   struct passwd *pw;
  500.   struct stat sbuf;
  501.   char *s,tmp[MAILTMPLEN];
  502.   if (myUserName) fatal ("env_init called twice!");
  503. /* set up user name */
  504.   myUserName = cpystr (user ? user : (char *) anonymous_user);
  505.   if (!anonymousHome) anonymousHome = cpystr (ANONYMOUSHOME);
  506.   if (user) { /* remember user name and home directory */
  507.     nslist[0] = &nshome,nslist[1] = &nsamigaother,nslist[2] = &nsshared;
  508.     myHomeDir = cpystr (home); /* use real home directory */
  509.   }
  510.   else { /* anonymous user */
  511.     nslist[0] = nslist[1] = NIL,nslist[2] = &nsftp;
  512.     sprintf (tmp,"%s/INBOX",myHomeDir = cpystr (anonymousHome));
  513.     sysInbox = cpystr (tmp); /* make system INBOX */
  514.     anonymous = T; /* flag as anonymous */
  515.   }
  516.   if (!myLocalHost) mylocalhost ();
  517.   if (!myNewsrc) myNewsrc = cpystr(strcat (strcpy (tmp,myHomeDir),"/.newsrc"));
  518.   if (!newsActive) newsActive = cpystr (ACTIVEFILE);
  519.   if (!newsSpool) newsSpool = cpystr (NEWSSPOOL);
  520.   if (!ftpHome && (pw = getpwnam ("ftp"))) ftpHome = cpystr (pw->pw_dir);
  521.   if (!publicHome && (pw = getpwnam ("imappublic")))
  522.     publicHome = cpystr (pw->pw_dir);
  523.   if (!anonymous && !sharedHome && (pw = getpwnam ("imapshared")))
  524.     sharedHome = cpystr (pw->pw_dir);
  525. /* force default prototype to be set */
  526.   if (!createProto) createProto = &CREATEPROTO;
  527.   if (!appendProto) appendProto = &EMPTYPROTO;
  528. /* re-do open action to get flags */
  529.   (*createProto->dtb->open) (NIL);
  530.   endpwent (); /* close pw database */
  531.   return T;
  532. }
  533.  
  534. /* Return my user name
  535.  * Accepts: pointer to optional flags
  536.  * Returns: my user name
  537.  */
  539. char *myusername_full (unsigned long *flags)
  540. {
  541.   char *ret = (char *) unlogged_user;
  542.   if (!myUserName) { /* get user name if don't have it yet */
  543.     struct passwd *pw;
  544.     unsigned long euid = geteuid ();
  545.     char *s = (char *) (euid ? getlogin () : NIL);
  546. /* look up getlogin() user name or EUID */
  547.     if (!((s && *s && (pw = getpwnam (s)) && (pw->pw_uid == euid)) ||
  548.   (pw = getpwuid (euid)))) fatal ("Unable to look up user name");
  549. /* init environment if not root */
  550.     if (euid) env_init (pw->pw_name,((s=getenv("HOME")) && *s) ? s:pw->pw_dir);
  551.     else ret = pw->pw_name; /* in case UID 0 user is other than root */
  552.   }
  553.   if (myUserName) { /* logged in? */
  554.     if (flags) *flags = anonymous ? MU_ANONYMOUS : MU_LOGGEDIN;
  555.     ret = myUserName; /* return user name */
  556.   }
  557.   else if (flags) *flags = MU_NOTLOGGEDIN;
  558.   return ret;
  559. }
  562. /* Return my local host name
  563.  * Returns: my local host name
  564.  */
  566. char *mylocalhost ()
  567. {
  568.   char tmp[MAILTMPLEN];
  569.   struct hostent *host_name;
  570.   if (!myLocalHost) {
  571.     gethostname(tmp,MAILTMPLEN);/* get local host name */
  572.     myLocalHost = cpystr ((host_name = gethostbyname (tmp)) ?
  573.   host_name->h_name : tmp);
  574.   }
  575.   return myLocalHost;
  576. }
  578. /* Return my home directory name
  579.  * Returns: my home directory name
  580.  */
  582. char *myhomedir ()
  583. {
  584.   if (!myHomeDir) myusername ();/* initialize if first time */
  585.   return myHomeDir ? myHomeDir : "";
  586. }
  589. /* Return system standard INBOX
  590.  * Accepts: buffer string
  591.  */
  593. char *sysinbox ()
  594. {
  595.   char tmp[MAILTMPLEN];
  596.   if (!sysInbox) { /* initialize if first time */
  597.     sprintf (tmp,"%s/%s",MAILSPOOL,myusername ());
  598.     sysInbox = cpystr (tmp); /* system inbox is from mail spool */
  599.   }
  600.   return sysInbox;
  601. }
  604. /* Return mailbox directory name
  605.  * Accepts: destination buffer
  606.  *     directory prefix
  607.  *     name in directory
  608.  * Returns: file name or NIL if error
  609.  */
  611. char *mailboxdir (char *dst,char *dir,char *name)
  612. {
  613.   char tmp[MAILTMPLEN];
  614.   if (dir || name) { /* if either argument provided */
  615.     if (dir) strcpy (tmp,dir); /* write directory prefix */
  616.     else tmp[0] = ''; /* otherwise null string */
  617.     if (name) strcat (tmp,name);/* write name in directory */
  618. /* validate name, return its name */
  619.     if (!mailboxfile (dst,tmp)) return NIL;
  620.   }
  621.   else strcpy (dst,myhomedir());/* no arguments, wants home directory */
  622.   return dst; /* return the name */
  623. }
  625. /* Return mailbox file name
  626.  * Accepts: destination buffer
  627.  *     mailbox name
  628.  * Returns: file name or empty string for driver-selected INBOX or NIL if error
  629.  */
  631. char *mailboxfile (char *dst,char *name)
  632. {
  633.   struct passwd *pw;
  634.   char *dir = myhomedir ();
  635.   *dst = ''; /* default to empty string */
  636. /* check invalid name */
  637.   if (!name || !*name || (*name == '{')) return NIL;
  638. /* check for INBOX */
  639.   if (((name[0] == 'I') || (name[0] == 'i')) &&
  640.       ((name[1] == 'N') || (name[1] == 'n')) &&
  641.       ((name[2] == 'B') || (name[2] == 'b')) &&
  642.       ((name[3] == 'O') || (name[3] == 'o')) &&
  643.       ((name[4] == 'X') || (name[4] == 'x')) && !name[5]) {
  644. /* if restricted, canonicalize name of INBOX */
  645.     if (anonymous) name = "INBOX";
  646.     else return dst; /* else driver selects the INBOX name */
  647.   }
  648. /* restricted name? */
  649.   else if ((*name == '#') || anonymous) {
  650.     if (strstr (name,"..") || strstr (name,"//") || strstr (name,"/~"))
  651.       return NIL; /* none of these allowed when restricted */
  652.     switch (*name) { /* what kind of restricted name? */
  653.     case '#': /* namespace name */
  654.       if (((name[1] == 'f') || (name[1] == 'F')) &&
  655.   ((name[2] == 't') || (name[2] == 'T')) &&
  656.   ((name[3] == 'p') || (name[3] == 'P')) &&
  657.   (name[4] == '/') && (dir = ftpHome)) name += 5;
  658.       else if (((name[1] == 'p') || (name[1] == 'P')) &&
  659.        ((name[2] == 'u') || (name[2] == 'U')) &&
  660.        ((name[3] == 'b') || (name[3] == 'B')) &&
  661.        ((name[4] == 'l') || (name[4] == 'L')) &&
  662.        ((name[5] == 'i') || (name[5] == 'I')) &&
  663.        ((name[6] == 'c') || (name[6] == 'C')) &&
  664.        (name[7] == '/') && (dir = publicHome)) name += 8;
  665.       else if (!anonymous && ((name[1] == 's') || (name[1] == 'S')) &&
  666.        ((name[2] == 'h') || (name[2] == 'H')) &&
  667.        ((name[3] == 'a') || (name[3] == 'A')) &&
  668.        ((name[4] == 'r') || (name[4] == 'R')) &&
  669.        ((name[5] == 'e') || (name[5] == 'E')) &&
  670.        ((name[6] == 'd') || (name[6] == 'D')) &&
  671.        (name[7] == '/') && (dir = sharedHome)) name += 8;
  672.       else return NIL; /* unknown namespace name */
  673.       break;
  674.     case '/': /* rooted restricted name */
  675.       return NIL; /* anonymous can't do this */
  676.     }
  677.   }
  679. /* absolute path name? */
  680.   else if (*name == '/') return strcpy (dst,name);
  681. /* some home directory? */
  682.   else if ((*name == '~') && *++name) {
  683.     if (*name == '/') name++; /* yes, my home directory? */
  684.     else { /* no, copy user name */
  685.       for (dir = dst; *name && (*name != '/'); *dir++ = *name++);
  686.       *dir++ = ''; /* tie off user name, look up in passwd file */
  687.       if (!((pw = getpwnam (dst)) && (dir = pw->pw_dir))) return NIL;
  688.       if (*name) name++; /* skip past the slash */
  689.     }
  690.   }
  691. /* build resulting name */
  692.   sprintf (dst,"%s/%s",dir,name);
  693.   return dst; /* return it */
  694. }
  696. /* Dot-lock file locker
  697.  * Accepts: file name to lock
  698.  *     destination buffer for lock file name
  699.  *     open file description on file name to lock
  700.  * Returns: T if success, NIL if failure
  701.  */
  703. long dotlock_lock (char *file,DOTLOCK *base,int fd)
  704. {
  705.   int ld,j;
  706.   int i = locktimeout * 60 - 1;
  707.   char *s,hitch[MAILTMPLEN],tmp[MAILTMPLEN];
  708.   time_t t;
  709.   struct stat sb;
  710. /* flush absurd file name */
  711.   if (strlen (file) > 512) return NIL;
  712. /* build lock filename */
  713.   sprintf (base->lock,"%s.lock",file);
  714. /* assume no pipe */
  715.   base->pipei = base->pipeo = -1;
  716. /* until OK or out of tries */
  717.   if (j = chk_notsymlink (base->lock,&sb)) do {
  718.     t = time (0); /* get the time now */
  719. /* time out old locks */
  720.     if ((j > 0) && (t >= (sb.st_ctime + locktimeout * 60))) {
  721.       unlink (base->lock); /* flush extant old lock */
  722.       j = O_WRONLY | O_CREAT; /* try to grab it for ourselves */
  723.     }
  724.     else j = O_WRONLY | O_CREAT | O_EXCL;
  725. /* try to get the lock */
  726.     if ((ld = open (strcpy (hitch,base->lock),j,(int) lock_protection)) >= 0)
  727.       close (ld); /* close the lock file */
  729.     else switch (errno) { /* what happened? */
  730.       case EACCES: /* protection fail */
  731. if (stat (hitch,&sb)) { /* file exists, fall into EEXIST case */
  732.   int pi[2],po[2];
  733. /* make command pipes */
  734.   if (!stat (LOCKPGM,&sb) && pipe (pi) >= 0) {
  735.     if (pipe (po) >= 0) {
  736. /* make inferior process */
  737.       if (!(j = fork ())) {
  738. if (!fork ()) { /* make grandchild so it's inherited by init */
  739.   char *argv[4];/* prepare argument vector for */
  740.   sprintf (tmp,"%d",fd);
  741.   argv[0] = LOCKPGM; argv[1] = tmp;
  742.   argv[2] = file; argv[3] = NIL;
  743. /* set parent's I/O to my O/I */
  744.   dup2 (pi[1],1); dup2 (pi[1],2); dup2 (po[0],0);
  745. /* close all unnecessary descriptors */
  746.   for (j = max (20,max (max (pi[0],pi[1]),max (po[0],po[1])));
  747.        j >= 3; --j) if (j != fd) close (j);
  748. /* be our own process group */
  749.   setpgrp (0,getpid ());
  750. /* now run it */
  751.   execv (argv[0],argv);
  752. }
  753. _exit (1); /* child is done */
  754.       }
  755.       else if (j > 0) { /* reap child; grandchild now owned by init */
  756. grim_pid_reap (j,NIL);
  757. /* read response from locking program */
  758. if ((read (pi[0],tmp,1) == 1) && (tmp[0] == '+')) {
  759. /* success, record pipes */
  760.   base->pipei = pi[0]; base->pipeo = po[1];
  761. /* close child's side of the pipes */
  762.   close (pi[1]); close (po[0]);
  763.   return LONGT;
  764. }
  765.       }
  766.       close (po[0]); close (po[1]);
  767.     }
  768.     close (pi[0]); close (pi[1]);
  769.   }
  770.   if (lockEaccesError) {/* punt silently if paranoid site */
  771.     sprintf (tmp,"Mailbox vulnerable - directory %.80s",hitch);
  772.     if (s = strrchr (tmp,'/')) *s = '';
  773.     strcat (tmp," must have 1777 protection");
  774.     mm_log (tmp,WARN);
  775.   }
  776.   base->lock[0] = ''; /* give up on lock file */
  777. }
  779.       case EEXIST: /* file already exists */
  780. break; /* try again */
  781.       default: /* some other failure */
  782. sprintf (tmp,"Mailbox vulnerable - error creating %.80s: %s",
  783.  hitch,strerror (errno));
  784. mm_log (tmp,WARN); /* this is probably not good */
  785. base->lock[0] = ''; /* don't use lock files */
  786. break;
  787.       }
  788. /* if failed to make lock file and retry OK */
  789.     if ((ld < 0) && base->lock) {
  790.       if (!(i%15)) { /* time to notify? */
  791. sprintf (tmp,"Mailbox %.80s is locked, will override in %d seconds...",
  792.  file,i);
  793. mm_log (tmp,WARN);
  794.       }
  795.       sleep (1); /* wait 1 second before next try */
  796.     }
  797.   } while (i-- && (ld < 0) && base->lock[0]);
  798. /* failed if no longer a lock name */
  799.   if (!base->lock[0]) return NIL;
  800. /* make sure others can break the lock */
  801.   chmod (base->lock,(int) lock_protection);
  802.   return LONGT;
  803. }
  806. /* Dot-lock file unlocker
  807.  * Accepts: lock file name
  808.  * Returns: T if success, NIL if failure
  809.  */
  811. long dotlock_unlock (DOTLOCK *base)
  812. {
  813.   long ret = LONGT;
  814.   if (base && base->lock[0]) {
  815.     if (base->pipei >= 0) { /* if running through a pipe unlocker */
  816.       ret = (write (base->pipeo,"+",1) == 1);
  817. /* nuke the pipes */
  818.       close (base->pipei); close (base->pipeo);
  819.     }
  820.     else ret = !unlink (base->lock);
  821.   }
  822.   return ret;
  823. }
  825. /* Lock file name
  826.  * Accepts: scratch buffer
  827.  *     file name
  828.  *     type of locking operation (LOCK_SH or LOCK_EX)
  829.  *     pointer to return PID of locker
  830.  * Returns: file descriptor of lock or negative if error
  831.  */
  833. int lockname (char *lock,char *fname,int op,long *pid)
  834. {
  835.   struct stat sbuf;
  836.   *pid = 0; /* no locker PID */
  837.   return stat (fname,&sbuf) ? -1 : lock_work (lock,&sbuf,op,pid);
  838. }
  841. /* Lock file descriptor
  842.  * Accepts: file descriptor
  843.  *     lock file name buffer
  844.  *     type of locking operation (LOCK_SH or LOCK_EX)
  845.  * Returns: file descriptor of lock or negative if error
  846.  */
  848. int lockfd (int fd,char *lock,int op)
  849. {
  850.   struct stat sbuf;
  851.   return fstat (fd,&sbuf) ? -1 : lock_work (lock,&sbuf,op,NIL);
  852. }
  854. /* Lock file name worker
  855.  * Accepts: lock file name
  856.  *     pointer to stat() buffer
  857.  *     type of locking operation (LOCK_SH or LOCK_EX)
  858.  *     pointer to return PID of locker
  859.  * Returns: file descriptor of lock or negative if error
  860.  */
  862. int lock_work (char *lock,void *sb,int op,long *pid)
  863. {
  864.   struct stat lsb,fsb;
  865.   struct stat *sbuf = sb;
  866.   char tmp[MAILTMPLEN];
  867.   long i;
  868.   int fd;
  869.   if (pid) *pid = 0; /* initialize return PID */
  870. /* make temporary lock file name */
  871.   sprintf (lock,"/tmp/.%lx.%lx",(unsigned long) sbuf->st_dev,
  872.    (unsigned long) sbuf->st_ino);
  873.   while (T) { /* until get a good lock */
  874.     do switch ((int) chk_notsymlink (lock,&lsb)) {
  875.     case 1: /* exists just once */
  876.       if (((fd = open (lock,O_RDWR,lock_protection)) >= 0) ||
  877.   (errno != ENOENT) || (chk_notsymlink (lock,&lsb) >= 0)) break;
  878.     case -1: /* name doesn't exist */
  879.       fd = open (lock,O_RDWR|O_CREAT|O_EXCL,lock_protection);
  880.       break;
  881.     default: /* multiple hard links */
  882.       mm_log ("hard link to lock name",ERROR);
  883.       syslog (LOG_CRIT,"SECURITY PROBLEM: hard link to lock name: %.80s",lock);
  884.     case 0: /* symlink (already did syslog) */
  885.       return -1; /* fail: no lock file */
  886.     } while ((fd < 0) && (errno == EEXIST));
  887.     if (fd < 0) { /* failed to get file descriptor */
  888.       syslog (LOG_INFO,"Mailbox lock file %s open failure: %s",lock,
  889.       strerror (errno));
  890.       return -1; /* fail: can't open lock file */
  891.     }
  892. /* non-blocking form */
  893.     if (op & LOCK_NB) i = flock (fd,op);
  894.     else { /* blocking form */
  895.       (*mailblocknotify) (BLOCK_FILELOCK,NIL);
  896.       i = flock (fd,op);
  897.       (*mailblocknotify) (BLOCK_NONE,NIL);
  898.     }
  899.     if (i) { /* failed, get other process' PID */
  900.       if (pid && !fstat (fd,&fsb) && (i = min (fsb.st_size,MAILTMPLEN-1)) &&
  901.   (read (fd,tmp,i) == i) && !(tmp[i] = 0) && ((i = atol (tmp)) > 0))
  902. *pid = i;
  903.       close (fd); /* failed, give up on lock */
  904.       return -1; /* fail: can't lock */
  905.     }
  906. /* make sure this lock is good for us */
  907.     if (!lstat (lock,&lsb) && ((lsb.st_mode & S_IFMT) != S_IFLNK) &&
  908. !fstat (fd,&fsb) && (lsb.st_dev == fsb.st_dev) &&
  909. (lsb.st_ino == fsb.st_ino) && (fsb.st_nlink == 1)) break;
  910.     close (fd); /* lock not right, drop fd and try again */
  911.   }
  912. /* make sure mode OK (don't use fchmod()) */
  913.   chmod (lock,(int) lock_protection);
  914.   return fd; /* success */
  915. }
  917. /* Check to make sure not a symlink
  918.  * Accepts: file name
  919.  *     stat buffer
  920.  * Returns: -1 if doesn't exist, NIL if symlink, else number of hard links
  921.  */
  923. long chk_notsymlink (char *name,void *sb)
  924. {
  925.   struct stat *sbuf = sb;
  926. /* name exists? */
  927.   if (lstat (name,sbuf)) return -1;
  928. /* forbid symbolic link */
  929.   if ((sbuf->st_mode & S_IFMT) == S_IFLNK) {
  930.     mm_log ("symbolic link on lock name",ERROR);
  931.     syslog (LOG_CRIT,"SECURITY PROBLEM: symbolic link on lock name: %.80s",
  932.     name);
  933.     return NIL;
  934.   }
  935.   return (long) sbuf->st_nlink; /* return number of hard links */
  936. }
  939. /* Unlock file descriptor
  940.  * Accepts: file descriptor
  941.  *     lock file name from lockfd()
  942.  */
  944. void unlockfd (int fd,char *lock)
  945. {
  946. /* delete the file if no sharers */
  947.   if (!flock (fd,LOCK_EX|LOCK_NB)) unlink (lock);
  948.   flock (fd,LOCK_UN); /* unlock it */
  949.   close (fd); /* close it */
  950. }
  952. /* Set proper file protection for mailbox
  953.  * Accepts: mailbox name
  954.  *     actual file path name
  955.  * Returns: T, always
  956.  */
  958. long set_mbx_protections (char *mailbox,char *path)
  959. {
  960.   struct stat sbuf;
  961.   int mode = (int) mbx_protection;
  962.   if (*mailbox == '#') { /* possible namespace? */
  963.       if (((mailbox[1] == 'f') || (mailbox[1] == 'F')) &&
  964.   ((mailbox[2] == 't') || (mailbox[2] == 'T')) &&
  965.   ((mailbox[3] == 'p') || (mailbox[3] == 'P')) &&
  966.   (mailbox[4] == '/')) mode = (int) ftp_protection;
  967.       else if (((mailbox[1] == 'p') || (mailbox[1] == 'P')) &&
  968.        ((mailbox[2] == 'u') || (mailbox[2] == 'U')) &&
  969.        ((mailbox[3] == 'b') || (mailbox[3] == 'B')) &&
  970.        ((mailbox[4] == 'l') || (mailbox[4] == 'L')) &&
  971.        ((mailbox[5] == 'i') || (mailbox[5] == 'I')) &&
  972.        ((mailbox[6] == 'c') || (mailbox[6] == 'C')) &&
  973.        (mailbox[7] == '/')) mode = (int) public_protection;
  974.       else if (((mailbox[1] == 's') || (mailbox[1] == 'S')) &&
  975.        ((mailbox[2] == 'h') || (mailbox[2] == 'H')) &&
  976.        ((mailbox[3] == 'a') || (mailbox[3] == 'A')) &&
  977.        ((mailbox[4] == 'r') || (mailbox[4] == 'R')) &&
  978.        ((mailbox[5] == 'e') || (mailbox[5] == 'E')) &&
  979.        ((mailbox[6] == 'd') || (mailbox[6] == 'D')) &&
  980.        (mailbox[7] == '/')) mode = (int) shared_protection;
  981.   }
  982. /* if a directory */
  983.   if (!stat (path,&sbuf) && ((sbuf.st_mode & S_IFMT) == S_IFDIR)) {
  984. /* set owner search if allow read or write */
  985.     if (mode & 0600) mode |= 0100;
  986.     if (mode & 060) mode |= 010;/* set group search if allow read or write */
  987.     if (mode & 06) mode |= 01; /* set world search if allow read or write */
  988.   }
  989.   chmod (path,mode); /* set the new protection, ignore failure */
  990.   return LONGT;
  991. }
  993. /* Determine default prototype stream to user
  994.  * Accepts: type (NIL for create, T for append)
  995.  * Returns: default prototype stream
  996.  */
  998. MAILSTREAM *default_proto (long type)
  999. {
  1000.   myusername (); /* make sure initialized */
  1001. /* return default driver's prototype */
  1002.   return type ? appendProto : createProto;
  1003. }
  1006. /* Set up user flags for stream
  1007.  * Accepts: MAIL stream
  1008.  * Returns: MAIL stream with user flags set up
  1009.  */
  1011. MAILSTREAM *user_flags (MAILSTREAM *stream)
  1012. {
  1013.   int i;
  1014.   myusername (); /* make sure initialized */
  1015.   for (i = 0; i < NUSERFLAGS && userFlags[i]; ++i)
  1016.     if (!stream->user_flags[i]) stream->user_flags[i] = cpystr (userFlags[i]);
  1017.   return stream;
  1018. }
  1021. /* Return nth user flag
  1022.  * Accepts: user flag number
  1023.  * Returns: flag
  1024.  */
  1026. char *default_user_flag (unsigned long i)
  1027. {
  1028.   myusername (); /* make sure initialized */
  1029.   return userFlags[i];
  1030. }
  1032. /* Default block notify routine
  1033.  * Accepts: reason for calling
  1034.  *     data
  1035.  * Returns: data
  1036.  */
  1038. void *mm_blocknotify (int reason,void *data)
  1039. {
  1040.   void *ret = data;
  1041.   switch (reason) {
  1042.   case BLOCK_SENSITIVE: /* entering sensitive code */
  1043.     data = (void *) max (alarm (0),1);
  1044.     break;
  1045.   case BLOCK_NONSENSITIVE: /* exiting sensitive code */
  1046.     if ((unsigned int) data) alarm ((unsigned int) data);
  1047.     break;
  1048.   default: /* ignore all other reasons */
  1049.     break;
  1050.   }
  1051.   return ret;
  1052. }