home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume16 / month8.7 / part05 < prev    next >
Text File  |  1988-11-08  |  40KB  |  1,645 lines
  1. Subject:  v16i058:  A visual calendar and appointment system, Part05/06
  2. Newsgroups: comp.sources.unix
  3. Sender: sources
  4. Approved: rsalz@uunet.UU.NET
  5.  
  6. Submitted-by: Michael Morrell <hplabs!hpda!morrell>
  7. Posting-number: Volume 16, Issue 58
  8. Archive-name: month8.7/part05
  9.  
  10. # This is a shell archive.  Remove anything before this line,
  11. # then unpack it by saving it in a file and typing "sh file".
  12. # This archive contains:
  13. #    monthd.c    xmonthd.c    chmonth.c    
  14. LANG=""; export LANG
  15.  
  16. echo x - monthd.c
  17. cat >monthd.c <<'@EOF'
  18. #ifndef lint
  19. static char rcsid[] = "$Header: monthd.c,v 8.5 88/04/04 11:09:01 hull Exp $";
  20. #endif
  21.  
  22. #include <stdio.h>
  23. #include <signal.h>
  24. #include <sys/types.h>
  25. #include <ctype.h>
  26. #include "month.h"
  27.  
  28. short dhour, dminute, dsecond;
  29. short days;
  30. short my_file = 1;
  31. short month_start;
  32. unsigned short file_owner;
  33. char *month_dir = NULL;
  34. char *prog_name;
  35. int dint = 15 * 60;    /* default wake-up interval is 15 minutes */
  36. int user_id;
  37. int parent_pid;
  38. int fd;
  39. FILE *tty;
  40. struct date_rec current_date, todays_date;
  41. struct event_rec events = {{0, 0, 0}, 0, 0, 0, {0, 0, 0, 0, 0, 0, 0},
  42. 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, {0, 0}, 0, 0, 0, 0, 0, {0, 0, 0}, 0};
  43.  
  44. extern char *get_home_dir();
  45. extern alarm_t alarm();
  46. extern unsigned short getuid();
  47.  
  48. main(argc, argv)
  49. int argc;
  50. char *argv[];
  51. {
  52.     int sig_terminate();
  53.  
  54.     prog_name = argv[0];
  55.     user_id = (int) getuid();
  56.     parent_pid = getppid();
  57.     tty = fopen("/dev/tty", "w");
  58.     /*
  59.     fprintf(tty, "%s: pid = %d\n", prog_name, getpid());
  60.     fprintf(tty, "%s: parent_pid = %d\n", prog_name, parent_pid);
  61.     fprintf(tty, "%s: pgrp = %d\n", prog_name, getpgrp());
  62.     */
  63.     month_dir = get_home_dir(user_id);
  64.     check_args(argc, argv);
  65.     close(0); close(1); close(2);    /* close stdin, stdout, stderr */
  66.     if (fork() == 0) {
  67.         signal(SIGHUP, sig_terminate);    /* child process */
  68.         signal(SIGTERM, sig_terminate);
  69.         signal(SIGINT, SIG_IGN);
  70.         signal(SIGQUIT, SIG_IGN);
  71. #ifdef SIGTSTP
  72.         signal(SIGTSTP, SIG_IGN);
  73.         signal(SIGTTIN, SIG_IGN);
  74.         signal(SIGTTOU, SIG_IGN);
  75. #endif
  76.         /*
  77.         fprintf(tty, "%s: child pid = %d\n", prog_name, getpid());
  78.         fprintf(tty, "%s: child pgrp before setpgrp2 = %d\n",
  79.         prog_name, getpgrp());
  80.         */
  81. #ifdef SIGTSTP
  82. #ifdef hpux
  83.         setpgrp2(0, parent_pid);
  84. #else
  85.         setpgrp(0, parent_pid);
  86. #endif
  87. #endif
  88.         inf_loop();
  89.     }
  90.  
  91.     /*
  92.     fprintf(tty, "%s: parent exiting\n", prog_name);
  93.     */
  94.     exit(0);
  95.     /* NOTREACHED */
  96. }
  97.  
  98. check_args(argc, argv)
  99. int argc;
  100. char *argv[];
  101. {
  102.     int err_flag = 0, c;
  103.     extern char *optarg;
  104.     extern int optind;
  105.  
  106.     while ((c = getopt(argc, argv, "i:")) != EOF) {
  107.         switch (c) {
  108.         case 'i':
  109.         if (isdigit(optarg[0]) && (optarg[0] > '0'))
  110.             dint = atoi(optarg) * 60;
  111.         else {
  112.             fprintf(stderr, "%s: invalid number -- %s\n",
  113.             prog_name, optarg);
  114.             err_flag++;
  115.         }
  116.         break;
  117.         case '?':
  118.             err_flag++;
  119.         break;
  120.         }
  121.     }
  122.  
  123.     if (err_flag) {
  124.         fprintf(stderr, "Usage: %s [-in]\n", prog_name);
  125.         exit(1);
  126.     }
  127. }
  128.  
  129. inf_loop()
  130. {
  131.     int stat, do_nothing();
  132.     struct event_rec *eptr;
  133.     short minutes, eminutes, wminutes, diff;
  134.     alarm_t seconds;
  135.  
  136.     for (;;) {
  137.         signal(SIGALRM, do_nothing);
  138.         if (get_todays_date() != 0) {
  139.         fprintf(tty, "%s: Cannot get today's date\n", prog_name);
  140.         exit(1);
  141.         }
  142.         seconds = dint - ((60 * dminute + dsecond) % dint);
  143.         if (seconds < 60)
  144.         seconds += dint;
  145.         alarm(seconds);
  146.         minutes = (60 * dhour) + dminute;
  147.         current_date.month = todays_date.month;
  148.         current_date.day = todays_date.day;
  149.         current_date.year = todays_date.year;
  150.         month_start = get_month_start(current_date.month,
  151.         current_date.year);
  152.         days = days_in(current_date.month, current_date.year);
  153.         if (stat = read_schedule(month_dir, READ_ONLY))
  154.         terminate(stat);
  155.  
  156.         eptr = events.next_event;
  157.  
  158.         while (eptr) {
  159.         if (event_today(eptr)) {
  160.             eminutes = (((short)60) * eptr->start_time.hour) +
  161.             eptr->start_time.minute;
  162.             wminutes = (((short)60) * eptr->warning.hour)
  163.             + eptr->warning.minute;
  164.             diff = eminutes - minutes;
  165.             if ((diff >= 0) && (diff <= wminutes))
  166.             print_reminder(eptr->event_string, diff);
  167.         }
  168.         eptr = eptr->next_event;
  169.         }
  170.         pause();
  171.         if (logged_out())
  172.         terminate(0);
  173.     }
  174. }
  175.  
  176. sig_terminate(sig)
  177. int sig;
  178. {
  179.     signal(SIGHUP, SIG_IGN);
  180.     signal(SIGTERM, SIG_IGN);
  181.     alarm((alarm_t) 0);
  182.  
  183.     /*
  184.     fprintf(tty, "%s: terminate(%d)\n", prog_name, sig);
  185.     */
  186.     exit(sig);
  187.     /* NOTREACHED */
  188. }
  189.  
  190. terminate(code)
  191. int code;
  192. {
  193.     signal(SIGHUP, SIG_IGN);
  194.     signal(SIGTERM, SIG_IGN);
  195.     alarm((alarm_t) 0);
  196.  
  197.     if (code < 0)
  198.         fprintf(tty, "%s: cannot open .month\n", prog_name);
  199.     else if (code > 0)
  200.         fprintf(tty, "%s: cannot read .month version %d\n",
  201.         prog_name, code);
  202.     exit(code);
  203.     /* NOTREACHED */
  204. }
  205.  
  206. print_reminder(str, minutes)
  207. char *str;
  208. int minutes;
  209. {
  210.     int hours;
  211.  
  212.     hours = minutes / 60;
  213.     minutes = minutes % 60;
  214.     fprintf(tty, "\r\n%s   \r\n", str);
  215.  
  216.     if ((hours == 0) && (minutes == 0))
  217.         fprintf(tty, "Right now");
  218.     else {
  219.         fprintf(tty, "In");
  220.         if (hours > 1)
  221.         fprintf(tty, " %d hours", hours);
  222.         else if (hours == 1)
  223.         fprintf(tty, " 1 hour");
  224.  
  225.         if (minutes > 1)
  226.         fprintf(tty, " %d minutes", minutes);
  227.         else if (minutes == 1)
  228.         fprintf(tty, " 1 minute");
  229.     }
  230.  
  231.     fprintf(tty, ".   \r\n\007");
  232. }
  233.  
  234. logged_out()
  235. {
  236.     /*
  237.     fprintf(tty, "%s: child pgrp = %d\n", prog_name, getpgrp());
  238.     */
  239. #if SYS5
  240.     return(getpgrp() == 0);    /* pgrp is 0 after logout */
  241. #else
  242.     return(getpgrp(0) == 0);/* pgrp is 0 after logout */
  243. #endif
  244. }
  245.  
  246. do_nothing()
  247. {
  248. }
  249. @EOF
  250.  
  251. chmod 644 monthd.c
  252.  
  253. echo x - xmonthd.c
  254. cat >xmonthd.c <<'@EOF'
  255. #ifndef lint
  256. static char rcsid[] = "$Header: xmonthd.c,v 1.4 88/04/04 11:11:18 hull Exp $";
  257. #endif
  258.  
  259. #include <stdio.h>
  260. #include <signal.h>
  261. #if SYS5
  262. #include <time.h>
  263. #else
  264. #include <sys/time.h>
  265. #endif
  266. #include <sys/types.h>
  267. #include <X/Xlib.h>
  268. #include "month.h"
  269.  
  270. #ifndef DEF_BORDER
  271. #define DEF_BORDER    2
  272. #endif
  273. #ifndef DEF_INTBORDER
  274. #define DEF_INTBORDER    2
  275. #endif
  276. #ifndef DEF_FONT
  277. #define DEF_FONT    "vtsingle"
  278. #endif
  279. #ifndef DEF_DELAY
  280. #define DEF_DELAY    5
  281. #endif
  282. #ifndef NUM_FLASH
  283. #define NUM_FLASH    10
  284. #endif
  285.  
  286. #define MAX_EVENT_TIME_LENGTH    24
  287. #define MAX(a, b)    ((a) > (b) ? (a) : (b))
  288.  
  289. struct remind_rec {
  290.     char event_string[MAX_EVENT_STRING_LENGTH];
  291.     char time_string[MAX_EVENT_TIME_LENGTH];
  292.     int time;
  293.     struct remind_rec *next;
  294. };
  295.  
  296. short dhour, dminute, dsecond;
  297. short days;
  298. short my_file = 1;
  299. short month_start;
  300. unsigned short file_owner;
  301. char *month_dir = NULL;
  302. char *prog_name;
  303. char *geom = NULL;
  304. char *display = NULL;
  305. char *Base_font = DEF_FONT;
  306. char *Fore_color;
  307. char *Back_color;
  308. char *Brdr_color;
  309. int reverse = 0;
  310. int num_flash = NUM_FLASH;
  311. FontInfo *base_font;
  312. int border = DEF_BORDER;
  313. int int_border = DEF_INTBORDER;
  314. int delay = DEF_DELAY;
  315. int fore_color;
  316. int back_color;
  317. int brdr_color;
  318. int width;
  319. int height;
  320. int xneg;
  321. int yneg;
  322. Window win;
  323. int have_new;
  324. int dint = 15 * 60;    /* default wake-up interval is 15 minutes */
  325. int user_id;
  326. int fd;
  327. struct remind_rec *remind_list = 0;
  328. struct date_rec current_date, todays_date;
  329. struct event_rec events = {{0, 0, 0}, 0, 0, 0, {0, 0, 0, 0, 0, 0, 0},
  330. 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, {0, 0}, 0, 0, 0, 0, 0, {0, 0, 0}, 0};
  331.  
  332. #if !SYS5
  333. #define strchr index
  334. #endif
  335. extern char *strcat(), *strcpy(), *strchr();
  336. extern char *get_home_dir();
  337. extern alarm_t alarm();
  338. extern unsigned short getuid();
  339.  
  340. main(argc, argv)
  341. int argc;
  342. char *argv[];
  343. {
  344.     char default_geom[20];
  345.     int mask, x, y, sig_terminate();
  346.     Color cdef;
  347.     OpaqueFrame frame;
  348.  
  349.     prog_name = argv[0];
  350.     user_id = (int) getuid();
  351.     month_dir = get_home_dir(user_id);
  352.     check_Xdefaults();
  353.     check_args(argc, argv);
  354.     close(0); close(1);    /* close stdin, stdout */
  355.     if (fork() == 0) {
  356.         signal(SIGHUP, sig_terminate);    /* child process */
  357.         signal(SIGTERM, sig_terminate);
  358.         signal(SIGINT, SIG_IGN);
  359.         signal(SIGQUIT, SIG_IGN);
  360. #ifdef SIGTSTP
  361.         signal(SIGTSTP, SIG_IGN);
  362.         signal(SIGTTIN, SIG_IGN);
  363.         signal(SIGTTOU, SIG_IGN);
  364. #endif
  365.  
  366.         /* Open X display. */
  367.  
  368.         if (XOpenDisplay(display) == NULL) {
  369.         fprintf(stderr, "%s: cannot open display\n", prog_name);
  370.         exit(1);
  371.         }
  372.  
  373.         /* Set up colors and pixmaps. */
  374.  
  375.         if (DisplayCells() > 2 &&
  376.         Brdr_color != NULL &&
  377.         XParseColor(Brdr_color, &cdef) &&
  378.         XGetHardwareColor(&cdef)
  379.         ) brdr_color = cdef.pixel;
  380.         else if (reverse) brdr_color = WhitePixel;
  381.         else brdr_color = BlackPixel;
  382.  
  383.         if (DisplayCells() > 2 &&
  384.         Fore_color != NULL &&
  385.         XParseColor(Fore_color, &cdef) &&
  386.         XGetHardwareColor(&cdef)
  387.         ) fore_color = cdef.pixel;
  388.         else if (reverse) fore_color = WhitePixel;
  389.         else fore_color = BlackPixel;
  390.  
  391.         if (DisplayCells() > 2 &&
  392.         Back_color != NULL &&
  393.         XParseColor(Back_color, &cdef) &&
  394.         XGetHardwareColor(&cdef)
  395.         ) back_color = cdef.pixel;
  396.         else if (reverse) back_color = BlackPixel;
  397.         else back_color = WhitePixel;
  398.  
  399.         /* Open the font */
  400.  
  401.         if ((base_font = XOpenFont(Base_font)) == NULL) {
  402.                 fprintf(stderr, "%s: cannot open font \"%s\"\n",
  403.             prog_name, Base_font);
  404.         exit(1);
  405.         }
  406.  
  407.         /* Determine if either xoffset and/or yoffset were negative */
  408.  
  409.         mask = XParseGeometry(geom, &x, &y, &width, &height);
  410.         xneg = mask & XNegative;
  411.         yneg = mask & YNegative;
  412.  
  413.         /* Create the window */
  414.  
  415.         width = base_font->width*MAX_EVENT_STRING_LENGTH + int_border*2;
  416.         height = base_font->height*2 + int_border*2;
  417.         sprintf(default_geom, "=%dx%d+0+0", width, height);
  418.         frame.bdrwidth = border;
  419.         frame.border = XMakeTile(brdr_color);
  420.         frame.background = XMakeTile(back_color);
  421.         if ((win = XCreate("month events", prog_name, geom, default_geom,
  422.               &frame, width, height)) == 0) {
  423.                 fprintf(stderr, "%s: cannot open window\n", prog_name);
  424.         exit(1);
  425.         }
  426.  
  427.         XSelectInput(win, ButtonPressed|ButtonReleased|ExposeWindow);
  428.         check_sched();
  429.         inf_loop();
  430.     }
  431.     exit(0);
  432.     /* NOTREACHED */
  433. }
  434.  
  435. check_Xdefaults()
  436. {
  437.     char *def_val;
  438.  
  439.     def_val = XGetDefault(prog_name, "Delay");
  440.     if (def_val != NULL) delay = atoi(def_val);
  441.  
  442.     def_val = XGetDefault(prog_name, "Flashes");
  443.     if (def_val != NULL) num_flash = atoi(def_val);
  444.  
  445.     def_val = XGetDefault(prog_name, "Geometry");
  446.     if (def_val != NULL) geom = def_val;
  447.  
  448.     def_val = XGetDefault(prog_name, "InternalBorder");
  449.     if (def_val != NULL) int_border = atoi(def_val);
  450.  
  451.     def_val = XGetDefault(prog_name, "Interval");
  452.     if (def_val != NULL) dint = atoi(def_val) * 60;
  453.  
  454.     def_val = XGetDefault(prog_name, "BorderWidth");
  455.     if (def_val != NULL) border = atoi(def_val);
  456.  
  457.     def_val = XGetDefault(prog_name, "BaseFont");
  458.     if (def_val != NULL) Base_font = def_val;
  459.  
  460.     Fore_color = XGetDefault(prog_name, "Foreground");
  461.     Back_color = XGetDefault(prog_name, "Background");
  462.     Brdr_color = XGetDefault(prog_name, "Border");
  463.  
  464.     def_val = XGetDefault(prog_name, "ReverseVideo");
  465.     if (def_val != NULL && strcmp(def_val, "on") == 0) reverse++;
  466. }
  467.  
  468. check_args(argc, argv)
  469. int argc;
  470. char *argv[];
  471. {
  472.     int i;
  473.  
  474.     for (i = 1; i < argc; i++) {
  475.         if (argv[i][0] == '=') {
  476.         geom = argv[i];
  477.         continue;
  478.         }
  479.         if (strchr(argv[i], ':') != (char *)NULL) {
  480.         display = argv[i];
  481.         continue;
  482.         }
  483.         fprintf(stderr, "Usage: %s [=geometry] [host:display]\n", prog_name);
  484.         exit(1);
  485.     }
  486. }
  487.  
  488. inf_loop()
  489. {
  490.     XEvent event;
  491.  
  492.     for (;;) {
  493.         XNextEvent(&event);
  494.  
  495.         switch(event.type) {
  496.         case ExposeWindow:
  497.         if (have_new) {
  498.             flash_window(num_flash);
  499.             have_new = 0;
  500.         } else
  501.             draw_window();
  502.         break;
  503.         case ButtonPressed:
  504.         XUnmapWindow(win);
  505.         break;
  506.         }
  507.     }
  508. }
  509.  
  510. sig_terminate(sig)
  511. int sig;
  512. {
  513.     signal(SIGHUP, SIG_IGN);
  514.     signal(SIGTERM, SIG_IGN);
  515.     alarm((alarm_t) 0);
  516.  
  517.     /*
  518.     fprintf(stderr, "%s: terminate(%d)\n", prog_name, sig);
  519.     */
  520.     exit(sig);
  521.     /* NOTREACHED */
  522. }
  523.  
  524. terminate(code)
  525. int code;
  526. {
  527.         signal(SIGHUP, SIG_IGN);
  528.         signal(SIGTERM, SIG_IGN);
  529.         alarm((alarm_t) 0);
  530.  
  531.         if (code < 0)
  532.             fprintf(stderr, "%s: cannot open .month\n", prog_name);
  533.         else if (code > 0)
  534.             fprintf(stderr, "%s: cannot read .month version %d\n",
  535.                 prog_name, code);
  536.         exit(code);
  537.         /* NOTREACHED */
  538. }
  539.  
  540. struct remind_rec *
  541. link_reminder(str, minutes)
  542. char *str;
  543. int minutes;
  544. {
  545.     int hours;
  546.     char buf[12];
  547.     struct remind_rec *remind;
  548.  
  549.     remind = (struct remind_rec *)malloc(sizeof(struct remind_rec));
  550.     strcpy(remind->event_string, str);
  551.     remind->time = minutes;
  552.     hours = minutes / 60;
  553.     minutes = minutes % 60;
  554.  
  555.     if ((hours == 0) && (minutes == 0))
  556.         strcpy(remind->time_string, "Right now");
  557.     else {
  558.         strcpy(remind->time_string, "In");
  559.         if (hours > 1) {
  560.         sprintf(buf, " %d hours", hours);
  561.         strcat(remind->time_string, buf);
  562.         } else if (hours == 1)
  563.         strcat(remind->time_string, " 1 hour");
  564.  
  565.         if (minutes > 1) {
  566.         sprintf(buf, " %d minutes", minutes);
  567.         strcat(remind->time_string, buf);
  568.         } else if (minutes == 1)
  569.         strcat(remind->time_string, " 1 minute");
  570.     }
  571.  
  572.     strcat(remind->time_string, ".");
  573.     remind->next = (struct remind_rec *)0;
  574.     return(remind);
  575. }
  576.  
  577. free_reminders(list)
  578. struct remind_rec *list;
  579. {
  580.     struct remind_rec *p;
  581.  
  582.     while (list) {
  583.         p = list->next;
  584.         free((char *) list);
  585.         list = p;
  586.     }
  587. }
  588.         
  589. sort_reminders()
  590. {
  591.     /* algorithm assumes at least one element in list */
  592.     struct remind_rec *o, *p, *q;
  593.     int swap;
  594.  
  595.     for (;;) {
  596.         o = (struct remind_rec *) 0;
  597.         p = remind_list;
  598.         q = p->next;
  599.         swap = 0;
  600.         while (q) {
  601.         if (p->time > q->time) {
  602.             p->next = q->next;
  603.             q->next = p;
  604.             if (o)
  605.             o->next = q;
  606.             else
  607.             remind_list = q;
  608.             swap = 1;
  609.             o = q;
  610.             q = p->next;
  611.         } else {
  612.             o = p;
  613.             p = q;
  614.             q = q->next;
  615.         }
  616.         }
  617.         if (swap == 0)
  618.         break;
  619.     }
  620. }
  621.  
  622. check_sched()
  623. {
  624.     int stat;
  625.     struct event_rec *eptr;
  626.     struct remind_rec *rptr;
  627.     short minutes, eminutes, wminutes, diff;
  628.     alarm_t seconds;
  629.  
  630.     signal(SIGALRM, check_sched);
  631.     if (get_todays_date() != 0) {
  632.         fprintf(stderr, "%s: Cannot get today's date\n", prog_name);
  633.         exit(1);
  634.     }
  635.     seconds = dint - ((60 * dminute + dsecond) % dint);
  636.     if (seconds < 60)
  637.         seconds += dint;
  638.     alarm(seconds);
  639.     minutes = (60 * dhour) + dminute;
  640.     current_date.month = todays_date.month;
  641.     current_date.day = todays_date.day;
  642.     current_date.year = todays_date.year;
  643.     month_start = get_month_start(current_date.month,
  644.         current_date.year);
  645.     days = days_in(current_date.month, current_date.year);
  646.     if (stat = read_schedule(month_dir, READ_ONLY))
  647.         terminate(stat);
  648.  
  649.     eptr = events.next_event;
  650.     have_new = 0;
  651.  
  652.     while (eptr) {
  653.         if (event_today(eptr)) {
  654.         eminutes = (((short)60) * eptr->start_time.hour) +
  655.             eptr->start_time.minute;
  656.         wminutes = (((short)60) * eptr->warning.hour)
  657.             + eptr->warning.minute;
  658.         diff = eminutes - minutes;
  659.         if ((diff >= 0) && (diff <= wminutes)) {
  660.             if (have_new++) {
  661.             rptr->next = link_reminder(eptr->event_string, diff);
  662.             rptr = rptr->next;
  663.             } else {
  664.             free_reminders(remind_list);
  665.             remind_list = link_reminder(eptr->event_string, diff);
  666.             rptr = remind_list;
  667.             }
  668.         }
  669.         }
  670.         eptr = eptr->next_event;
  671.     }
  672.  
  673.     if (have_new) {
  674.         sort_reminders();
  675.         map_window(have_new);
  676.     }
  677. }
  678.  
  679. map_window(num_events)
  680. int num_events;
  681. {
  682.     struct remind_rec *rptr = remind_list;
  683.     WindowInfo wininfo;
  684.  
  685.     width = 0;
  686.     while (rptr) {
  687.         width = MAX(width, XStringWidth(rptr->event_string, base_font,
  688.         0, 0));
  689.         width = MAX(width, XStringWidth(rptr->time_string, base_font,
  690.         0, 0));
  691.         rptr = rptr->next;
  692.     }
  693.  
  694.     width += (2 * int_border);
  695.     height = (3 * num_events - 1) * base_font->height + 2 * int_border;
  696.  
  697.     XQueryWindow(win, &wininfo);
  698.  
  699.     if (xneg)
  700.         wininfo.x += (wininfo.width - width);
  701.     if (yneg)
  702.         wininfo.y += (wininfo.height - height);
  703.  
  704.     XConfigureWindow(win, (int)wininfo.x, (int)wininfo.y, width, height);
  705.     XMapWindow(win);
  706.     XFeep(0);
  707.     XFlush();
  708. }
  709.  
  710. draw_window()
  711. {
  712.     struct remind_rec *rptr = remind_list;
  713.     int x = int_border;
  714.     int y = int_border;
  715.     int yline;
  716.  
  717.     XPixSet (win, 0, 0, width, height, back_color);
  718.  
  719.     while (rptr) {
  720.         XText(win, x, y, rptr->event_string, strlen(rptr->event_string),
  721.         base_font->id, fore_color, back_color);
  722.         y += base_font->height;
  723.         XText(win, x, y, rptr->time_string, strlen(rptr->time_string),
  724.         base_font->id, fore_color, back_color);
  725.         y += 2*base_font->height;
  726.         yline = y - base_font->height / 2;
  727.         if (y < height)
  728.         XLine(win, 0, yline, width - 1, yline, 1, 1,
  729.             brdr_color, GXcopy, AllPlanes);
  730.         rptr = rptr->next;
  731.     }
  732. }
  733.  
  734. flash_window(num)
  735. int num;
  736. {
  737.     int i, j;
  738.     int temp_color;
  739. #if defined(hpux) || !SYS5
  740.     static struct timeval delaytime;
  741.  
  742.     delaytime.tv_sec = 0;
  743.     delaytime.tv_usec = delay * 10000;
  744. #endif
  745.  
  746.     for (i = 0; i < num; i++) {
  747.         for (j = 0; j < 2; j++) {
  748.         temp_color = fore_color;
  749.         fore_color = back_color;
  750.         back_color = temp_color;
  751.         draw_window();
  752.         XFlush();
  753. #if defined(hpux) || !SYS5
  754.         (void) select (0, (fd_type *)0, (fd_type *)0, (fd_type *)0,
  755.             &delaytime);
  756. #endif
  757.         }
  758.     }
  759. }
  760. @EOF
  761.  
  762. chmod 644 xmonthd.c
  763.  
  764. echo x - chmonth.c
  765. cat >chmonth.c <<'@EOF'
  766. #ifndef lint
  767. static char rcsid[] = "$Header: chmonth.c,v 8.3 88/01/15 10:58:19 hull Exp $";
  768. #endif
  769.  
  770. #include <stdio.h>
  771. #include <sys/types.h>
  772. #if LOCKF
  773. #include <fcntl.h>
  774. #include <unistd.h>
  775. #endif LOCKF
  776. #if FLOCK
  777. #include <sys/file.h>
  778. #endif FLOCK
  779. #include <pwd.h>
  780. #include "month.h"
  781. #include "month2.h"
  782. #include "month3.h"
  783. #include "month4.h"
  784. #include "month5.h"
  785. #include "month6.h"
  786. #include "month7.h"
  787.  
  788. short updating, update_schedule = 1, keep_old = 1;
  789. int user_id, fd;
  790. char *month_dir = NULL;
  791. struct date_rec todays_date;
  792. struct event_rec2 events2 = {0, 0, 0, 0, 0, 0, {0, 0, 0, 0, 0, 0, 0},
  793. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  794. struct event_rec3 events3 = {0, 0, 0, 0, 0, 0, {0, 0, 0, 0, 0, 0, 0},
  795. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  796. struct event_rec4 events4 = {0, 0, 0, 0, 0, 0, {0, 0, 0, 0, 0, 0, 0},
  797. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  798. struct event_rec5 events5 = {0, 0, 0, 0, 0, 0, {0, 0, 0, 0, 0, 0, 0},
  799. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  800. struct event_rec6 events6 = {0, 0, 0, 0, 0, 0, {0, 0, 0, 0, 0, 0, 0},
  801. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  802. struct event_rec7 events7 = {{0, 0, 0}, 0, 0, 0, {0, 0, 0, 0, 0, 0, 0},
  803. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0};
  804. struct event_rec events = {{0, 0, 0}, 0, 0, 0, {0, 0, 0, 0, 0, 0, 0},
  805. 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, {0, 0}, 0, 0, 0, 0, 0, {0, 0, 0}, 0};
  806. extern char *strcat(), *strcpy();
  807. extern unsigned short getuid();
  808. extern float get_version();
  809.  
  810. char *
  811. get_user()
  812. {
  813.     struct passwd *pw;
  814.  
  815.     user_id = (int) getuid();
  816.  
  817.     if ((pw = getpwuid(user_id)) == NULL)
  818.         return(NULL);
  819.     else
  820.         return(pw->pw_dir);
  821. }
  822.  
  823. char *
  824. get_user_arg(arg)
  825. char *arg;
  826. {
  827.     struct passwd *pw;
  828.  
  829.     if ((pw = getpwnam(arg)) == NULL)
  830.         return(NULL);
  831.     else {
  832.         user_id = pw->pw_uid;
  833.         return(pw->pw_dir);
  834.     }
  835. }
  836.  
  837. check_args(argc, argv)
  838. int argc;
  839. char *argv[];
  840. {
  841.     switch(argc) {
  842.     case 1:
  843.         if ((month_dir = get_user()) == NULL) {
  844.             printf("%s: No passwd entry\n", argv[0]);
  845.             printf("Usage: %s [user]\n", argv[0]);
  846.             exit(1);
  847.         }
  848.         user_id = (int) getuid();
  849.         break;
  850.     case 2:
  851.         if ((month_dir = get_user_arg(argv[1])) == NULL) {
  852.             printf("%s: No such user -- %s\n", argv[0], argv[1]);
  853.             printf("Usage: %s [user]\n", argv[0]);
  854.             exit(1);
  855.         }
  856.         break;
  857.     default:
  858.         printf("Usage: %s [user]\n", argv[0]);
  859.         exit(1);
  860.  
  861.     }
  862. }
  863.  
  864. main(argc, argv)
  865. int argc;
  866. char *argv[];
  867. {
  868.     int ret;
  869.  
  870.     check_args(argc, argv);
  871.     if ((ret = read_schedule7(month_dir)) == 0)
  872.         convert_schedule7();
  873.     else if ((ret = read_schedule6(month_dir)) == 0)
  874.         convert_schedule6();
  875.     else if ((ret = read_schedule5(month_dir)) == 0)
  876.         convert_schedule5();
  877.     else if ((ret = read_schedule4(month_dir)) == 0)
  878.         convert_schedule4();
  879.     else if ((ret = read_schedule3(month_dir)) == 0)
  880.         convert_schedule3();
  881.     else
  882.         if (ret == -2) {
  883.         printf(".month file locked\n");
  884.         exit(1);
  885.         } else if (ret == -1) {
  886.         printf("cannot open .month\n");
  887.         exit(1);
  888.         } else if (ret == (int) get_version()) {
  889.         printf(".month file is up-to-date\n");
  890.         exit(2);
  891.         } else
  892.         if ((ret = read_schedule2(month_dir)) == 0)
  893.             convert_schedule2();
  894.         else
  895.             if (ret == -2) {
  896.             printf(".month file locked\n");
  897.             exit(1);
  898.             } else if (ret == -1) {
  899.             printf("cannot open .month\n");
  900.             exit(1);
  901.             }
  902.  
  903.     if (write_schedule() < 0) {
  904.         printf("cannot write .month\n");
  905.         exit(1);
  906.     }
  907.  
  908.     exit(0);
  909.     /* NOTREACHED */
  910. }
  911.  
  912. read_schedule2(m_dir)
  913. char *m_dir;
  914. {
  915.     char *schedule_file_name;
  916.     unsigned rec_size;
  917.     struct event_rec2 event_buf, *event_ptr, *chain_ptr;
  918.  
  919. #ifdef DEBUG
  920.     printf("reading schedule");
  921. #endif
  922.     events2.next_event = 0;
  923.  
  924.     schedule_file_name = malloc((unsigned) strlen(m_dir)+8);
  925.     strcpy(schedule_file_name, m_dir);
  926.     strcat(schedule_file_name, "/.month");
  927. #ifdef DEBUG
  928.     printf(" %s\n", schedule_file_name);
  929. #endif
  930.  
  931.     rec_size = sizeof(struct event_rec2);
  932.  
  933. #if MULTIUSER
  934.     if ((fd = open(schedule_file_name, O_RDWR|O_CREAT)) != -1)
  935. #if LOCKF
  936.         if (lockf(fd, F_TLOCK, 0L) == -1)
  937. #else
  938. #if FLOCK
  939.         if (flock(fd, LOCK_EX | LOCK_NB) == -1)
  940. #endif FLOCK
  941. #endif LOCKF
  942.         return(-2);
  943. #else
  944.     fd = open(schedule_file_name, O_RDWR|O_CREAT);
  945. #endif MULTIUSER
  946.  
  947.     if (fd != -1) {
  948.         chain_ptr = &events2;
  949.  
  950.         while (read(fd, &event_buf, rec_size) == rec_size) {
  951.             if (event_ptr = (struct event_rec2 *) malloc(rec_size)) {
  952.                 chain_ptr->next_event = event_ptr;
  953.                 chain_ptr = event_ptr;
  954.                 *chain_ptr = event_buf;
  955.                 chain_ptr->next_event = (struct event_rec2 *)0;
  956.             } else
  957.                 break;
  958.         }
  959.         return(0);
  960.     }
  961.     return(-1);
  962. }
  963.  
  964. convert_schedule2()
  965. {
  966.     struct event_rec *chain_ptr, *event_ptr;
  967.     struct event_rec2 *chain_ptr2;
  968.  
  969. #ifdef DEBUG
  970.     printf("converting schedule\n");
  971. #endif
  972.     chain_ptr = &events;
  973.     chain_ptr2 = events2.next_event;
  974.  
  975.     while (chain_ptr2) {
  976.         if (event_ptr = (struct event_rec *) malloc(sizeof(struct event_rec))) {
  977.             chain_ptr->next_event = event_ptr;
  978.             chain_ptr = event_ptr;
  979.             copy_event2(chain_ptr2, chain_ptr);
  980.             chain_ptr->next_event = (struct event_rec *)0;
  981.         } else
  982.             break;
  983.         chain_ptr2 = chain_ptr2->next_event;
  984.     }
  985. }
  986.  
  987. copy_event2(event_ptr2, event_ptr)
  988. struct event_rec2 *event_ptr2;
  989. struct event_rec *event_ptr;
  990. {
  991.     int i;
  992.  
  993.     event_ptr->start_date.month = event_ptr2->event_month;
  994.     event_ptr->start_date.day = event_ptr2->event_day;
  995.     event_ptr->start_date.year = event_ptr2->event_year;
  996.     event_ptr->monthly = event_ptr2->monthly;
  997.     event_ptr->yearly = event_ptr2->yearly;
  998.     event_ptr->every = event_ptr2->every;
  999.     for (i = 0; i < 7; i++)
  1000.         event_ptr->smtwtfs[i] = event_ptr2->smtwtfs[i];
  1001.     event_ptr->nth = event_ptr2->nth;
  1002.     event_ptr->last = event_ptr2->last;
  1003.     event_ptr->nth_is_on = event_ptr2->nth_is_on;
  1004.     event_ptr->start_time.hour = event_ptr2->hour;
  1005.     event_ptr->start_time.minute = event_ptr2->minute;
  1006.     event_ptr->duration.hour = event_ptr2->duration_hours;
  1007.     event_ptr->duration.minute = event_ptr2->duration_minutes;
  1008.     event_ptr->warning.hour = 0;
  1009.     event_ptr->warning.minute = 15;
  1010.     event_ptr->end_time.minute = event_ptr->start_time.minute +
  1011.         event_ptr->duration.minute;
  1012.     event_ptr->end_time.hour = (event_ptr->start_time.hour +
  1013.         event_ptr->duration.hour + (event_ptr->end_time.minute / 60)) % 24;
  1014.     event_ptr->end_time.minute %= 60;
  1015.     for (i = 0; i < MAX_EVENT_STRING_LENGTH; i++)
  1016.         event_ptr->event_string[i] = event_ptr2->event_string[i];
  1017.     event_ptr->private = event_ptr2->private;
  1018.     event_ptr->event_owner = user_id;
  1019.     event_ptr->until = 0;
  1020.     event_ptr->until_date.month = event_ptr2->event_month;
  1021.     event_ptr->until_date.day = event_ptr2->event_day;
  1022.     event_ptr->until_date.year = event_ptr2->event_year;
  1023. }
  1024.  
  1025. read_schedule3(m_dir)
  1026. char *m_dir;
  1027. {
  1028.     char *schedule_file_name;
  1029.     unsigned rec_size;
  1030.     short file_version;
  1031.     struct event_rec3 event_buf, *event_ptr, *chain_ptr;
  1032.  
  1033. #ifdef DEBUG
  1034.     printf("reading schedule");
  1035. #endif
  1036.     schedule_file_name = malloc((unsigned) strlen(m_dir)+8);
  1037.     strcpy(schedule_file_name, m_dir);
  1038.     strcat(schedule_file_name, "/.month");
  1039. #ifdef DEBUG
  1040.     printf(" %s\n", schedule_file_name);
  1041. #endif
  1042.  
  1043.     rec_size = sizeof(struct event_rec3);
  1044.     umask(0);
  1045.  
  1046. #if MULTIUSER
  1047.     if ((fd = open(schedule_file_name, O_RDWR|O_CREAT)) != -1)
  1048. #if LOCKF
  1049.         if (lockf(fd, F_TLOCK, 0L) == -1)
  1050. #else
  1051. #if FLOCK
  1052.         if (flock(fd, LOCK_EX | LOCK_NB) == -1)
  1053. #endif FLOCK
  1054. #endif LOCKF
  1055.         return(-2);
  1056. #else
  1057.     fd = open(schedule_file_name, O_RDWR|O_CREAT);
  1058. #endif MULTIUSER
  1059.  
  1060.     if (fd != -1) {
  1061.         events3.next_event = 0;
  1062.  
  1063.         if (read(fd, (char *) &file_version, sizeof(file_version)) !=
  1064.             sizeof(file_version))
  1065.             return(-1);
  1066.         if (file_version != 3)
  1067.             return(file_version);
  1068.  
  1069.         chain_ptr = &events3;
  1070.  
  1071.         while (read(fd, &event_buf, rec_size) == rec_size) {
  1072.             if (event_ptr = (struct event_rec3 *) malloc(rec_size)) {
  1073.                 chain_ptr->next_event = event_ptr;
  1074.                 chain_ptr = event_ptr;
  1075.                 *chain_ptr = event_buf;
  1076.                 chain_ptr->next_event = (struct event_rec3 *)0;
  1077.             } else
  1078.                 break;
  1079.         }
  1080.         return(0);
  1081.     }
  1082.     return(-1);
  1083. }
  1084.  
  1085. convert_schedule3()
  1086. {
  1087.     struct event_rec *chain_ptr, *event_ptr;
  1088.     struct event_rec3 *chain_ptr3;
  1089.  
  1090. #ifdef DEBUG
  1091.     printf("converting schedule\n");
  1092. #endif
  1093.     chain_ptr = &events;
  1094.     chain_ptr3 = events3.next_event;
  1095.  
  1096.     while (chain_ptr3) {
  1097.         if (event_ptr = (struct event_rec *) malloc(sizeof(struct event_rec))) {
  1098.             chain_ptr->next_event = event_ptr;
  1099.             chain_ptr = event_ptr;
  1100.             copy_event3(chain_ptr3, chain_ptr);
  1101.             chain_ptr->next_event = (struct event_rec *)0;
  1102.         } else
  1103.             break;
  1104.         chain_ptr3 = chain_ptr3->next_event;
  1105.     }
  1106. }
  1107.  
  1108. copy_event3(event_ptr3, event_ptr)
  1109. struct event_rec3 *event_ptr3;
  1110. struct event_rec *event_ptr;
  1111. {
  1112.     int i;
  1113.  
  1114.     event_ptr->start_date.month = event_ptr3->event_month;
  1115.     event_ptr->start_date.day = event_ptr3->event_day;
  1116.     event_ptr->start_date.year = event_ptr3->event_year;
  1117.     event_ptr->monthly = event_ptr3->monthly;
  1118.     event_ptr->yearly = event_ptr3->yearly;
  1119.     event_ptr->every = event_ptr3->every;
  1120.     for (i = 0; i < 7; i++)
  1121.         event_ptr->smtwtfs[i] = event_ptr3->smtwtfs[i];
  1122.     event_ptr->nth = event_ptr3->nth;
  1123.     event_ptr->last = event_ptr3->last;
  1124.     event_ptr->nth_is_on = event_ptr3->nth_is_on;
  1125.     event_ptr->start_time.hour = event_ptr3->hour;
  1126.     event_ptr->start_time.minute = event_ptr3->minute;
  1127.     event_ptr->duration.hour = event_ptr3->duration_hours;
  1128.     event_ptr->duration.minute = event_ptr3->duration_minutes;
  1129.     event_ptr->warning.hour = 0;
  1130.     event_ptr->warning.minute = 15;
  1131.     event_ptr->end_time.minute = event_ptr->start_time.minute +
  1132.         event_ptr->duration.minute;
  1133.     event_ptr->end_time.hour = (event_ptr->start_time.hour +
  1134.         event_ptr->duration.hour + (event_ptr->end_time.minute / 60)) % 24;
  1135.     event_ptr->end_time.minute %= 60;
  1136.     for (i = 0; i < MAX_EVENT_STRING_LENGTH; i++)
  1137.         event_ptr->event_string[i] = event_ptr3->event_string[i];
  1138.     event_ptr->private = event_ptr3->private;
  1139.     event_ptr->event_owner = event_ptr3->event_owner;
  1140.     event_ptr->until = 0;
  1141.     event_ptr->until_date.month = event_ptr3->event_month;
  1142.     event_ptr->until_date.day = event_ptr3->event_day;
  1143.     event_ptr->until_date.year = event_ptr3->event_year;
  1144. }
  1145.  
  1146. read_schedule4(m_dir)
  1147. char *m_dir;
  1148. {
  1149.     char *schedule_file_name;
  1150.     unsigned rec_size;
  1151.     short file_version;
  1152.     struct event_rec4 event_buf, *event_ptr, *chain_ptr;
  1153.  
  1154. #ifdef DEBUG
  1155.     printf("reading schedule");
  1156. #endif
  1157.     schedule_file_name = malloc((unsigned) strlen(m_dir)+8);
  1158.     strcpy(schedule_file_name, m_dir);
  1159.     strcat(schedule_file_name, "/.month");
  1160. #ifdef DEBUG
  1161.     printf(" %s\n", schedule_file_name);
  1162. #endif
  1163.  
  1164.     rec_size = sizeof(struct event_rec4);
  1165.     umask(0);
  1166.  
  1167. #if MULTIUSER
  1168.     if ((fd = open(schedule_file_name, O_RDWR|O_CREAT)) != -1)
  1169. #if LOCKF
  1170.         if (lockf(fd, F_TLOCK, 0L) == -1)
  1171. #else
  1172. #if FLOCK
  1173.         if (flock(fd, LOCK_EX | LOCK_NB) == -1)
  1174. #endif FLOCK
  1175. #endif LOCKF
  1176.         return(-2);
  1177. #else
  1178.     fd = open(schedule_file_name, O_RDWR|O_CREAT);
  1179. #endif MULTIUSER
  1180.  
  1181.     if (fd != -1) {
  1182.         events4.next_event = 0;
  1183.  
  1184.         if (read(fd, (char *) &file_version, sizeof(file_version)) !=
  1185.             sizeof(file_version))
  1186.             return(-1);
  1187.         if (file_version != 4)
  1188.             return(file_version);
  1189.  
  1190.         chain_ptr = &events4;
  1191.  
  1192.         while (read(fd, &event_buf, rec_size) == rec_size) {
  1193.             if (event_ptr = (struct event_rec4 *) malloc(rec_size)) {
  1194.                 chain_ptr->next_event = event_ptr;
  1195.                 chain_ptr = event_ptr;
  1196.                 *chain_ptr = event_buf;
  1197.                 chain_ptr->next_event = (struct event_rec4 *)0;
  1198.             } else
  1199.                 break;
  1200.         }
  1201.         return(0);
  1202.     }
  1203.     return(-1);
  1204. }
  1205.  
  1206. convert_schedule4()
  1207. {
  1208.     struct event_rec *chain_ptr, *event_ptr;
  1209.     struct event_rec4 *chain_ptr4;
  1210.  
  1211. #ifdef DEBUG
  1212.     printf("converting schedule\n");
  1213. #endif
  1214.     chain_ptr = &events;
  1215.     chain_ptr4 = events4.next_event;
  1216.  
  1217.     while (chain_ptr4) {
  1218.         if (event_ptr = (struct event_rec *) malloc(sizeof(struct event_rec))) {
  1219.             chain_ptr->next_event = event_ptr;
  1220.             chain_ptr = event_ptr;
  1221.             copy_event4(chain_ptr4, chain_ptr);
  1222.             chain_ptr->next_event = (struct event_rec *)0;
  1223.         } else
  1224.             break;
  1225.         chain_ptr4 = chain_ptr4->next_event;
  1226.     }
  1227. }
  1228.  
  1229. copy_event4(event_ptr4, event_ptr)
  1230. struct event_rec4 *event_ptr4;
  1231. struct event_rec *event_ptr;
  1232. {
  1233.     int i;
  1234.  
  1235.     event_ptr->start_date.month = event_ptr4->start_month;
  1236.     event_ptr->start_date.day = event_ptr4->start_day;
  1237.     event_ptr->start_date.year = event_ptr4->start_year;
  1238.     event_ptr->monthly = event_ptr4->monthly;
  1239.     event_ptr->yearly = event_ptr4->yearly;
  1240.     event_ptr->every = event_ptr4->every;
  1241.     for (i = 0; i < 7; i++)
  1242.         event_ptr->smtwtfs[i] = event_ptr4->smtwtfs[i];
  1243.     event_ptr->nth = event_ptr4->nth;
  1244.     event_ptr->last = event_ptr4->last;
  1245.     event_ptr->nth_is_on = event_ptr4->nth_is_on;
  1246.     event_ptr->start_time.hour = event_ptr4->hour;
  1247.     event_ptr->start_time.minute = event_ptr4->minute;
  1248.     event_ptr->duration.hour = event_ptr4->duration_hours;
  1249.     event_ptr->duration.minute = event_ptr4->duration_minutes;
  1250.     event_ptr->warning.hour = 0;
  1251.     event_ptr->warning.minute = 15;
  1252.     event_ptr->end_time.minute = event_ptr->start_time.minute +
  1253.         event_ptr->duration.minute;
  1254.     event_ptr->end_time.hour = (event_ptr->start_time.hour +
  1255.         event_ptr->duration.hour + (event_ptr->end_time.minute / 60)) % 24;
  1256.     event_ptr->end_time.minute %= 60;
  1257.     for (i = 0; i < MAX_EVENT_STRING_LENGTH; i++)
  1258.         event_ptr->event_string[i] = event_ptr4->event_string[i];
  1259.     event_ptr->private = event_ptr4->private;
  1260.     event_ptr->event_owner = event_ptr4->event_owner;
  1261.     event_ptr->until = event_ptr4->until;
  1262.     event_ptr->until_date.month = event_ptr4->until_month;
  1263.     event_ptr->until_date.day = event_ptr4->until_day;
  1264.     event_ptr->until_date.year = event_ptr4->until_year;
  1265. }
  1266.  
  1267. read_schedule5(m_dir)
  1268. char *m_dir;
  1269. {
  1270.     char *schedule_file_name;
  1271.     unsigned rec_size;
  1272.     short file_version;
  1273.     struct event_rec5 event_buf, *event_ptr, *chain_ptr;
  1274.  
  1275. #ifdef DEBUG
  1276.     printf("reading schedule");
  1277. #endif
  1278.     schedule_file_name = malloc((unsigned) strlen(m_dir)+8);
  1279.     strcpy(schedule_file_name, m_dir);
  1280.     strcat(schedule_file_name, "/.month");
  1281. #ifdef DEBUG
  1282.     printf(" %s\n", schedule_file_name);
  1283. #endif
  1284.  
  1285.     rec_size = sizeof(struct event_rec5);
  1286.     umask(0);
  1287.  
  1288. #if MULTIUSER
  1289.     if ((fd = open(schedule_file_name, O_RDWR|O_CREAT)) != -1)
  1290. #if LOCKF
  1291.         if (lockf(fd, F_TLOCK, 0L) == -1)
  1292. #else
  1293. #if FLOCK
  1294.         if (flock(fd, LOCK_EX | LOCK_NB) == -1)
  1295. #endif FLOCK
  1296. #endif LOCKF
  1297.         return(-2);
  1298. #else
  1299.     fd = open(schedule_file_name, O_RDWR|O_CREAT);
  1300. #endif MULTIUSER
  1301.  
  1302.     if (fd != -1) {
  1303.         events5.next_event = 0;
  1304.  
  1305.         if (read(fd, (char *) &file_version, sizeof(file_version)) !=
  1306.             sizeof(file_version))
  1307.             return(-1);
  1308.         if (file_version != 5)
  1309.             return(file_version);
  1310.  
  1311.         chain_ptr = &events5;
  1312.  
  1313.         while (read(fd, &event_buf, rec_size) == rec_size) {
  1314.             if (event_ptr = (struct event_rec5 *) malloc(rec_size)) {
  1315.                 chain_ptr->next_event = event_ptr;
  1316.                 chain_ptr = event_ptr;
  1317.                 *chain_ptr = event_buf;
  1318.                 chain_ptr->next_event = (struct event_rec5 *)0;
  1319.             } else
  1320.                 break;
  1321.         }
  1322.         return(0);
  1323.     }
  1324.     return(-1);
  1325. }
  1326.  
  1327. convert_schedule5()
  1328. {
  1329.     struct event_rec *chain_ptr, *event_ptr;
  1330.     struct event_rec5 *chain_ptr5;
  1331.  
  1332. #ifdef DEBUG
  1333.     printf("converting schedule\n");
  1334. #endif
  1335.     chain_ptr = &events;
  1336.     chain_ptr5 = events5.next_event;
  1337.  
  1338.     while (chain_ptr5) {
  1339.         if (event_ptr = (struct event_rec *) malloc(sizeof(struct event_rec))) {
  1340.             chain_ptr->next_event = event_ptr;
  1341.             chain_ptr = event_ptr;
  1342.             copy_event5(chain_ptr5, chain_ptr);
  1343.             chain_ptr->next_event = (struct event_rec *)0;
  1344.         } else
  1345.             break;
  1346.         chain_ptr5 = chain_ptr5->next_event;
  1347.     }
  1348. }
  1349.  
  1350. copy_event5(event_ptr5, event_ptr)
  1351. struct event_rec5 *event_ptr5;
  1352. struct event_rec *event_ptr;
  1353. {
  1354.     int i;
  1355.  
  1356.     event_ptr->start_date.month = event_ptr5->start_month;
  1357.     event_ptr->start_date.day = event_ptr5->start_day;
  1358.     event_ptr->start_date.year = event_ptr5->start_year;
  1359.     event_ptr->monthly = event_ptr5->monthly;
  1360.     event_ptr->yearly = event_ptr5->yearly;
  1361.     event_ptr->every = event_ptr5->every;
  1362.     for (i = 0; i < 7; i++)
  1363.         event_ptr->smtwtfs[i] = event_ptr5->smtwtfs[i];
  1364.     event_ptr->nth = event_ptr5->nth;
  1365.     event_ptr->last = event_ptr5->last;
  1366.     event_ptr->nth_is_on = event_ptr5->nth_is_on;
  1367.     event_ptr->start_time.hour = event_ptr5->hour;
  1368.     event_ptr->start_time.minute = event_ptr5->minute;
  1369.     event_ptr->duration.hour = event_ptr5->duration_hours;
  1370.     event_ptr->duration.minute = event_ptr5->duration_minutes;
  1371.     event_ptr->warning.hour = event_ptr5->warning_hours;
  1372.     event_ptr->warning.minute = event_ptr5->warning_minutes;
  1373.     event_ptr->end_time.minute = event_ptr->start_time.minute +
  1374.         event_ptr->duration.minute;
  1375.     event_ptr->end_time.hour = (event_ptr->start_time.hour +
  1376.         event_ptr->duration.hour + (event_ptr->end_time.minute / 60)) % 24;
  1377.     event_ptr->end_time.minute %= 60;
  1378.     for (i = 0; i < MAX_EVENT_STRING_LENGTH; i++)
  1379.         event_ptr->event_string[i] = event_ptr5->event_string[i];
  1380.     event_ptr->private = event_ptr5->private;
  1381.     event_ptr->anti = 0;
  1382.     event_ptr->event_owner = event_ptr5->event_owner;
  1383.     event_ptr->until = event_ptr5->until;
  1384.     event_ptr->until_date.month = event_ptr5->until_month;
  1385.     event_ptr->until_date.day = event_ptr5->until_day;
  1386.     event_ptr->until_date.year = event_ptr5->until_year;
  1387. }
  1388.  
  1389. read_schedule6(m_dir)
  1390. char *m_dir;
  1391. {
  1392.     char *schedule_file_name;
  1393.     unsigned rec_size;
  1394.     short file_version;
  1395.     struct event_rec6 event_buf, *event_ptr, *chain_ptr;
  1396.  
  1397. #ifdef DEBUG
  1398.     printf("reading schedule");
  1399. #endif
  1400.     schedule_file_name = malloc((unsigned) strlen(m_dir)+8);
  1401.     strcpy(schedule_file_name, m_dir);
  1402.     strcat(schedule_file_name, "/.month");
  1403. #ifdef DEBUG
  1404.     printf(" %s\n", schedule_file_name);
  1405. #endif
  1406.  
  1407.     rec_size = sizeof(struct event_rec6);
  1408.     umask(0);
  1409.  
  1410. #if MULTIUSER
  1411.     if ((fd = open(schedule_file_name, O_RDWR|O_CREAT)) != -1)
  1412. #if LOCKF
  1413.         if (lockf(fd, F_TLOCK, 0L) == -1)
  1414. #else
  1415. #if FLOCK
  1416.         if (flock(fd, LOCK_EX | LOCK_NB) == -1)
  1417. #endif FLOCK
  1418. #endif LOCKF
  1419.         return(-2);
  1420. #else
  1421.     fd = open(schedule_file_name, O_RDWR|O_CREAT);
  1422. #endif MULTIUSER
  1423.  
  1424.     if (fd != -1) {
  1425.         events6.next_event = 0;
  1426.  
  1427.         if (read(fd, (char *) &file_version, sizeof(file_version)) !=
  1428.             sizeof(file_version))
  1429.             return(-1);
  1430.         if (file_version != 6)
  1431.             return(file_version);
  1432.  
  1433.         chain_ptr = &events6;
  1434.  
  1435.         while (read(fd, &event_buf, rec_size) == rec_size) {
  1436.             if (event_ptr = (struct event_rec6 *) malloc(rec_size)) {
  1437.                 chain_ptr->next_event = event_ptr;
  1438.                 chain_ptr = event_ptr;
  1439.                 *chain_ptr = event_buf;
  1440.                 chain_ptr->next_event = (struct event_rec6 *)0;
  1441.             } else
  1442.                 break;
  1443.         }
  1444.         return(0);
  1445.     }
  1446.     return(-1);
  1447. }
  1448.  
  1449. convert_schedule6()
  1450. {
  1451.     struct event_rec *chain_ptr, *event_ptr;
  1452.     struct event_rec6 *chain_ptr6;
  1453.  
  1454. #ifdef DEBUG
  1455.     printf("converting schedule\n");
  1456. #endif
  1457.     chain_ptr = &events;
  1458.     chain_ptr6 = events6.next_event;
  1459.  
  1460.     while (chain_ptr6) {
  1461.         if (event_ptr = (struct event_rec *) malloc(sizeof(struct event_rec))) {
  1462.             chain_ptr->next_event = event_ptr;
  1463.             chain_ptr = event_ptr;
  1464.             copy_event6(chain_ptr6, chain_ptr);
  1465.             chain_ptr->next_event = (struct event_rec *)0;
  1466.         } else
  1467.             break;
  1468.         chain_ptr6 = chain_ptr6->next_event;
  1469.     }
  1470. }
  1471.  
  1472. copy_event6(event_ptr6, event_ptr)
  1473. struct event_rec6 *event_ptr6;
  1474. struct event_rec *event_ptr;
  1475. {
  1476.     int i;
  1477.  
  1478.     event_ptr->start_date.month = event_ptr6->start_month;
  1479.     event_ptr->start_date.day = event_ptr6->start_day;
  1480.     event_ptr->start_date.year = event_ptr6->start_year;
  1481.     event_ptr->monthly = event_ptr6->monthly;
  1482.     event_ptr->yearly = event_ptr6->yearly;
  1483.     event_ptr->every = event_ptr6->every;
  1484.     for (i = 0; i < 7; i++)
  1485.         event_ptr->smtwtfs[i] = event_ptr6->smtwtfs[i];
  1486.     event_ptr->nth = event_ptr6->nth;
  1487.     event_ptr->last = event_ptr6->last;
  1488.     event_ptr->nth_is_on = event_ptr6->nth_is_on;
  1489.     event_ptr->start_time.hour = event_ptr6->hour;
  1490.     event_ptr->start_time.minute = event_ptr6->minute;
  1491.     event_ptr->duration.hour = event_ptr6->duration_hours;
  1492.     event_ptr->duration.minute = event_ptr6->duration_minutes;
  1493.     event_ptr->warning.hour = event_ptr6->warning_hours;
  1494.     event_ptr->warning.minute = event_ptr6->warning_minutes;
  1495.     event_ptr->end_time.minute = event_ptr->start_time.minute +
  1496.         event_ptr->duration.minute;
  1497.     event_ptr->end_time.hour = (event_ptr->start_time.hour +
  1498.         event_ptr->duration.hour + (event_ptr->end_time.minute / 60)) % 24;
  1499.     event_ptr->end_time.minute %= 60;
  1500.     for (i = 0; i < MAX_EVENT_STRING_LENGTH; i++)
  1501.         event_ptr->event_string[i] = event_ptr6->event_string[i];
  1502.     event_ptr->private = event_ptr6->private;
  1503.     event_ptr->anti = event_ptr6->anti;
  1504.     event_ptr->event_owner = event_ptr6->event_owner;
  1505.     event_ptr->until = event_ptr6->until;
  1506.     event_ptr->until_date.month = event_ptr6->until_month;
  1507.     event_ptr->until_date.day = event_ptr6->until_day;
  1508.     event_ptr->until_date.year = event_ptr6->until_year;
  1509. }
  1510.  
  1511. read_schedule7(m_dir)
  1512. char *m_dir;
  1513. {
  1514.     char *schedule_file_name;
  1515.     unsigned rec_size;
  1516.     short file_version;
  1517.     struct event_rec7 event_buf, *event_ptr, *chain_ptr;
  1518.  
  1519. #ifdef DEBUG
  1520.     printf("reading schedule");
  1521. #endif
  1522.     schedule_file_name = malloc((unsigned) strlen(m_dir)+8);
  1523.     strcpy(schedule_file_name, m_dir);
  1524.     strcat(schedule_file_name, "/.month");
  1525. #ifdef DEBUG
  1526.     printf(" %s\n", schedule_file_name);
  1527. #endif
  1528.  
  1529.     rec_size = sizeof(struct event_rec7);
  1530.     umask(0);
  1531.  
  1532. #if MULTIUSER
  1533.     if ((fd = open(schedule_file_name, O_RDWR|O_CREAT)) != -1)
  1534. #if LOCKF
  1535.         if (lockf(fd, F_TLOCK, 0L) == -1)
  1536. #else
  1537. #if FLOCK
  1538.         if (flock(fd, LOCK_EX | LOCK_NB) == -1)
  1539. #endif FLOCK
  1540. #endif LOCKF
  1541.         return(-2);
  1542. #else
  1543.     fd = open(schedule_file_name, O_RDWR|O_CREAT);
  1544. #endif MULTIUSER
  1545.  
  1546.     if (fd != -1) {
  1547.         events7.next_event = 0;
  1548.  
  1549.         if (read(fd, (char *) &file_version, sizeof(file_version)) !=
  1550.             sizeof(file_version))
  1551.             return(-1);
  1552.         if (file_version != 7)
  1553.             return(file_version);
  1554.  
  1555.         chain_ptr = &events7;
  1556.  
  1557.         while (read(fd, &event_buf, rec_size) == rec_size) {
  1558.             if (event_ptr = (struct event_rec7 *) malloc(rec_size)) {
  1559.                 chain_ptr->next_event = event_ptr;
  1560.                 chain_ptr = event_ptr;
  1561.                 *chain_ptr = event_buf;
  1562.                 chain_ptr->next_event = (struct event_rec7 *)0;
  1563.             } else
  1564.                 break;
  1565.         }
  1566.         return(0);
  1567.     }
  1568.     return(-1);
  1569. }
  1570.  
  1571. convert_schedule7()
  1572. {
  1573.     struct event_rec *chain_ptr, *event_ptr;
  1574.     struct event_rec7 *chain_ptr7;
  1575.  
  1576. #ifdef DEBUG
  1577.     printf("converting schedule\n");
  1578. #endif
  1579.     chain_ptr = &events;
  1580.     chain_ptr7 = events7.next_event;
  1581.  
  1582.     while (chain_ptr7) {
  1583.         if (event_ptr = (struct event_rec *) malloc(sizeof(struct event_rec))) {
  1584.             chain_ptr->next_event = event_ptr;
  1585.             chain_ptr = event_ptr;
  1586.             copy_event7(chain_ptr7, chain_ptr);
  1587.             chain_ptr->next_event = (struct event_rec *)0;
  1588.         } else
  1589.             break;
  1590.         chain_ptr7 = chain_ptr7->next_event;
  1591.     }
  1592. }
  1593.  
  1594. copy_event7(event_ptr7, event_ptr)
  1595. struct event_rec7 *event_ptr7;
  1596. struct event_rec *event_ptr;
  1597. {
  1598.     int i;
  1599.  
  1600.     event_ptr->start_date.month = event_ptr7->start_date.month;
  1601.     event_ptr->start_date.day = event_ptr7->start_date.day;
  1602.     event_ptr->start_date.year = event_ptr7->start_date.year;
  1603.     event_ptr->monthly = event_ptr7->monthly;
  1604.     event_ptr->yearly = event_ptr7->yearly;
  1605.     event_ptr->every = event_ptr7->every;
  1606.     for (i = 0; i < 7; i++)
  1607.         event_ptr->smtwtfs[i] = event_ptr7->smtwtfs[i];
  1608.     event_ptr->nth = event_ptr7->nth;
  1609.     event_ptr->last = event_ptr7->last;
  1610.     event_ptr->nth_is_on = event_ptr7->nth_is_on;
  1611.     event_ptr->start_time.hour = event_ptr7->hour;
  1612.     event_ptr->start_time.minute = event_ptr7->minute;
  1613.     event_ptr->duration.hour = event_ptr7->duration_hours;
  1614.     event_ptr->duration.minute = event_ptr7->duration_minutes;
  1615.     event_ptr->warning.hour = event_ptr7->warning_hours;
  1616.     event_ptr->warning.minute = event_ptr7->warning_minutes;
  1617.     event_ptr->end_time.minute = event_ptr->start_time.minute +
  1618.         event_ptr->duration.minute;
  1619.     event_ptr->end_time.hour = (event_ptr->start_time.hour +
  1620.         event_ptr->duration.hour + (event_ptr->end_time.minute / 60)) % 24;
  1621.     event_ptr->end_time.minute %= 60;
  1622.     for (i = 0; i < MAX_EVENT_STRING_LENGTH; i++)
  1623.         event_ptr->event_string[i] = event_ptr7->event_string[i];
  1624.     event_ptr->private = event_ptr7->private;
  1625.     event_ptr->anti = event_ptr7->anti;
  1626.     event_ptr->event_owner = event_ptr7->event_owner;
  1627.     event_ptr->until = event_ptr7->until;
  1628.     event_ptr->until_date.month = event_ptr7->until_date.month;
  1629.     event_ptr->until_date.day = event_ptr7->until_date.day;
  1630.     event_ptr->until_date.year = event_ptr7->until_date.year;
  1631. }
  1632.  
  1633. /* ARGSUSED */
  1634. delete_event(event)
  1635. struct event_rec *event;
  1636. {
  1637. /* dummy routine to satisfy reference in write_schedule */
  1638. }
  1639. @EOF
  1640.  
  1641. chmod 644 chmonth.c
  1642.  
  1643. exit 0
  1644.  
  1645.