home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / TELECOM / OSKBox.lzh / MAILBOX / CC / cleanup.c < prev    next >
C/C++ Source or Header  |  1993-02-19  |  6KB  |  271 lines
  1. #include <stdio.h>
  2. #include <ctype.h>
  3. #include <direct.h>
  4. #include <setjmp.h>
  5. #include <signal.h>
  6. #include <modes.h>
  7. #include <errno.h>
  8. #include "mailbox.h"
  9.  
  10. /* #define WPCLEAN */
  11.  
  12. #define msg_size (sizeof (struct msg_header))
  13.  
  14. struct userstruct user;
  15. int run_date, run_time;
  16. char *maildir = "MAIL/";
  17. int orphanflag;
  18.  
  19. main (argc, argv)
  20. char *argv[];
  21. {
  22.     int day, tick;
  23.  
  24.     while (--argc > 0 && (++argv)[0][0]=='-')
  25.         {
  26.         char *cp = argv[0] + 1;
  27.         while (*cp)
  28.             switch (*cp++)
  29.                 {
  30.  
  31.         case 'o':
  32.                 orphanflag++;
  33.                 continue;
  34.  
  35.         default:
  36.                 fprintf(stderr, "Unknown flag '%c'\n", *(cp-1));
  37.                 continue;
  38.                 }
  39.         }
  40.     chdir (HOME);
  41.     read_dist_list ();
  42.     strcpy (user.uscall, "CLEAN");
  43.     user.usopt = ISSUPER;
  44.     _sysdate (0, &run_time, &run_date, &day, &tick);
  45.     clean_killed ();
  46.     if (!orphanflag)
  47.         {
  48.         clean_read ();
  49.         clean_old ();
  50.         clean_ncwp ();
  51.         clean_owners ();
  52.         clean_users ();
  53.         }
  54.     clean_orphan ();
  55.     }
  56.  
  57. int kill_list[MAXMAIL], kill_num = 0;
  58.  
  59. clean_killed ()
  60. {
  61.     extern struct msg_header *mail_dir;
  62.     struct msg_header *head1, *head2;
  63.     int i, f;
  64.  
  65. printf ("Removing the following files:\n\n");
  66.     open_mail ();
  67.     write_lock ();
  68.     head1 = head2 = mail_dir;
  69.     while (head1 - mail_dir < MAXMAIL)
  70.         if (head1->mhstat != ' ' &&
  71.         (head1->mhstat == 'X' && (age (head1) > 2 || head1->mhsize == 0 ||
  72. #ifdef WPCLEAN
  73.             strcmp (head1->mhfrom, "WP") == 0 || strcmp (head1->mhto, "WP") == 0 ||
  74. #endif
  75.                                 *(head1->mhto) == '\0' || head1->mhtype == 'B'))) {
  76. print_header (head1, 1, 0);
  77.             head1->mhstat = ' ';
  78.             kill_list[kill_num++] = head1->mhnr;
  79.             head1++;
  80.             }
  81.         else {
  82.             if (head1 != head2)
  83.                 _strass (head2, head1, msg_size);
  84.             head1++;  head2++;
  85.             }
  86.     for ( ; head2 < head1; head2++)
  87.         head2->mhstat = ' ';
  88.     if ((f = open ("mail_dir", S_IWRITE)) < 0)
  89.         printf ("Error %d opening mail_dir.\n", errno);
  90.     else {
  91.         write (f, mail_dir, MAXMAIL * sizeof (struct msg_header));
  92.         close (f);
  93.         }
  94.     write_unlock ();
  95.     close_mail ();
  96.     for (i = 0; i < kill_num; i++)
  97.         {
  98.         char name[80];
  99.         struct msg_header hd;
  100.         
  101.         strcpy (name, maildir);
  102.         hd.mhnr = kill_list[i];
  103.         header_to_name (&hd, name + strlen (name));
  104.         if (unlink (name) == -1)
  105.             printf ("Error %d unlinking %s.\n", errno, name);
  106.         }
  107.     }
  108.  
  109. clean_read ()
  110. {
  111.     struct msg_header *head;
  112.  
  113.     open_mail ();
  114.     while ((head = next_mail (is_read, 0)) != NULL)
  115.         if (age (head) > 7) {
  116.             head->mhstat = 'X';
  117.             update_mail ();
  118.             log ("K %d", head->mhnr);
  119.             }
  120.     close_mail ();
  121.     }
  122.  
  123. clean_old ()
  124. {
  125.     struct msg_header *head;
  126.     int time, date, tick;
  127.     short day;
  128.     int d, t = 0;
  129.  
  130.     _sysdate (1, &time, &date, &day, &tick);
  131.     open_mail ();
  132.     while ((head = next_mail (is_gnum, 0)) != NULL) {
  133.         d = head->mhdate_xpir;
  134.         t = 0;
  135.         _julian (&t, &d);
  136.         if ((strcmp (head->mhto, "SALE") == 0 && age2 (head) > 7) ||
  137.             (strcmp (head->mhto, "WANTED") == 0 && age2 (head) > 14) ||
  138.             (head->mhdate_xpir && date > d)) {
  139.             head->mhstat = 'X';
  140.             update_mail ();
  141.             log ("K %d", head->mhnr);
  142.             }
  143.         }
  144.     close_mail ();
  145.     }
  146.  
  147. clean_ncwp ()
  148. {
  149.     struct msg_header *head;
  150.  
  151.     open_mail ();
  152.     while ((head = next_mail (is_gnum, 0)) != NULL) {
  153.         if (is_to (head, "WP") && is_at (head, "NCWP") && head->mhstat == 'F') {
  154.             head->mhstat = 'X';
  155.             update_mail ();
  156.             log ("K %d", head->mhnr);
  157.             }
  158.         }
  159.     close_mail ();
  160.     }
  161.  
  162. clean_orphan ()
  163. {
  164.     struct msg_header *head;
  165.     int f, mhnr;
  166.     char str[80];
  167.     int flag = 1;
  168.  
  169.     open_mail ();
  170.     while ((head = next_mail (is_gnum, 0)) != NULL)
  171.         if (age (head) > 1 && !bulletin (head))
  172.             break;
  173.     if (head) {
  174.         int time, date, day, tick;
  175.         
  176.         head = new_mail (0);
  177.         mhnr = head->mhnr;
  178.         strcpy (head->mhfrom, user.uscall);
  179.         strcpy (head->mhto, MYCALL);
  180.         head->mhtype = 'P';
  181.         head->mhstat = 'N';
  182.         head->mhbbs[0] = '\0';
  183.         strcpy (head->mhtit, "Orphan report");
  184.         strcpy (head->mhbid, "");
  185.         _sysdate (1, &time, &date, &day, &tick);
  186.         gregorian (&time, &date);
  187.         head->mhdate_xpir = date;    /* orphan reports live 24 hours */
  188.         update_mail ();
  189.         log_send (head, 0);
  190.         strcpy (str, maildir);
  191.         header_to_name (head, str + strlen (str));
  192.         f = create (str, S_IWRITE, S_IREAD+S_IWRITE);
  193.         sprintf (str, "The following orphan messages have been detected:\n\n");
  194.         write (f, str, strlen (str));
  195.         reset_mail ();
  196.         while ((head = next_mail (is_gnum, 0)) != NULL)
  197.             if (age (head) > 3 && !bulletin (head)
  198.                     && strcmp (head->mhto, MYCALL) != 0) {
  199.                 print_header (head, f, flag);
  200.                 flag = 0;
  201.                 }
  202.         sprintf (str, "\n73 DE %s \"cleanup\"\n", MYCALL);
  203.         write (f, str, strlen (str));
  204.         reset_mail ();
  205.         head = next_mail (is_num, mhnr);
  206.         head->mhsize = _gs_size (f);
  207.         update_mail ();
  208.         close (f);
  209.         }
  210.     close_mail ();
  211.     }
  212.  
  213. age (head)
  214. struct msg_header *head;
  215. {
  216.     int j1time, j1date;
  217.     int j2time, j2date;
  218.  
  219.     j1time = run_time;  j1date = run_date;
  220.     _julian (&j1time, &j1date);
  221.     j2time = 0;  j2date = head->mhdate_mod;
  222.     _julian (&j2time, &j2date);
  223.     return (j1date - j2date);
  224.     }
  225.  
  226. age2 (head)
  227. struct msg_header *head;
  228. {
  229.     int j1time, j1date;
  230.     int j2time, j2date;
  231.  
  232.     j1time = run_time;  j1date = run_date;
  233.     _julian (&j1time, &j1date);
  234.     j2time = 0;  j2date = head->mhdate;
  235.     _julian (&j2time, &j2date);
  236.     return (j1date - j2date);
  237.     }
  238.  
  239. clean_owners ()
  240. {
  241.     int f1, f2;
  242.     char line[80];
  243.     int len;
  244.  
  245.     if ((f1 = open ("file_owners", 1)) < 0) return;
  246.     f2 = creat ("file_owners.tmp", 3);
  247.     while (len = readln (f1, line, 80))
  248.         if (*line != '*')
  249.             write (f2, line, len);
  250.     close (f1);
  251.     close (f2);
  252.     unlink ("file_owners");
  253.     rename_file ("file_owners.tmp", "file_owners");
  254.     }
  255.  
  256. clean_users ()
  257. {
  258.     struct userstruct user;
  259.     int f1, f2;
  260.  
  261.     if ((f1 = open ("users", 1)) < 0) return;
  262.     f2 = creat ("users.tmp", 3);
  263.     while (read (f1, &user, sizeof (user)))
  264.         if (!(user.usopt & ISDELETED))
  265.             write (f2, &user, sizeof (user));
  266.     close (f1);
  267.     close (f2);
  268.     unlink ("users");
  269.     rename_file ("users.tmp", "users");
  270.     }
  271.