home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume13 / rolodex / part03 / rolo.c < prev   
Encoding:
C/C++ Source or Header  |  1988-01-30  |  17.9 KB  |  791 lines
  1. /* rolo.c */
  2. #ifdef UNIX
  3. #include <sys/types.h>
  4. #include <sys/stat.h>
  5. #include <pwd.h>
  6. #include <string.h>
  7. #ifdef BSD
  8. #include <sys/file.h>
  9. #else
  10. #include <fcntl.h>
  11. #endif
  12. #endif
  13.  
  14. #ifdef VMS
  15. #include <types.h>
  16. #include <file.h>
  17. #include <stat.h>
  18. #include <string.h>
  19. #endif
  20.  
  21. #ifdef MSDOS
  22. #include <fcntl.h>
  23. #    ifdef MSC
  24. #    include <sys    ypes.h>
  25. #    endif    /* MSC */
  26. #include <sys/stat.h>
  27. #include <errno.h>
  28. #include <string.h>
  29. #endif
  30.  
  31. #include <stdio.h>
  32. #include <ctype.h>
  33. /* #include <sgtty.h> */
  34. #include <signal.h>
  35.  
  36.  
  37. #ifdef TMC
  38. #include <ctools.h>
  39. #else
  40. #include "ctools.h"
  41. #endif
  42. #include "args.h"
  43. #include "menu.h"
  44. #include "mem.h"
  45.  
  46. #include "rolofilz.h"
  47. #include "rolodefs.h"
  48. #include "datadef.h"
  49.  
  50. #ifndef BSD
  51. /* BSD Unix gives us these values but AT&T Unix, VMS and MSDOS don't */
  52. /* Used with 'access(2)' syscall */
  53. #define R_OK 04
  54. #define F_OK 00
  55. #define W_OK 02
  56. #endif
  57.  
  58. #ifdef UNIX
  59. #define    DEF_PERM 0600    /* Default permissions: All, for owner only */
  60. #endif
  61.  
  62. #ifdef VMS
  63. #define    DEF_PERM 0600    /* Default permissions: All, for owner only */
  64. #endif
  65.  
  66. #ifdef MSDOS
  67. #define    DEF_PERM (S_IREAD | S_IWRITE)    /* Default permissions: All */
  68. #endif
  69.  
  70. #define MAX_LINES    60        /* Max number of lines/page */
  71.  
  72. static struct stat stat_buf;
  73.  
  74. static char rolodir[DIRPATHLEN];        /* directory where rolo data is */
  75. static char filebuf[DIRPATHLEN];        /* stores result of homedir() */
  76.  
  77. int changed = 0;
  78. int name_changed = 0;
  79. int reorder_file = 0;
  80. int rololocked = 0;
  81. int in_search_mode = 0;
  82. int read_only = 0;
  83.  
  84. char *rolo_emalloc (size) int size;
  85.  
  86. /* error handling memory allocator */
  87.  
  88. {
  89.   char *rval;        
  90.   char *malloc();
  91.   if (0 == (rval = malloc((unsigned)size))) {        
  92.      fprintf(stderr,"Fatal error:  out of memory\n");
  93.      save_and_exit(-1);                                               
  94.   }
  95.   return(rval);
  96. }  
  97.  
  98.         
  99. char *copystr (s) char *s;
  100.  
  101. /* memory allocating string copy routine */
  102.  
  103.  
  104. {
  105.  char *copy;        
  106.  if (s == 0) return(0);
  107.  copy = rolo_emalloc(strlen(s) + 1);
  108.  strcpy(copy,s);
  109.  return(copy);
  110. }
  111.  
  112.  
  113. char *timestring ()
  114.  
  115. /* returns a string timestamp */
  116.  
  117. {
  118.   char *s;        
  119.   long timeval;
  120.   long time();
  121.  
  122.   time(&timeval);
  123.   s = ctime(&timeval);  
  124.   s[strlen(s) - 1] = '\0';
  125.   return(copystr(s));
  126. }  
  127.   
  128.  
  129. user_interrupt ()
  130.  
  131. /* if the user hits C-C (we assume he does it deliberately) */
  132.  
  133. {
  134. #ifdef VMS
  135.   delete(homedir(ROLOLOCK));
  136.   delete(homedir(ROLOTEMP));
  137. #else
  138.   unlink(homedir(ROLOLOCK));
  139.   unlink(homedir(ROLOTEMP));
  140. #endif
  141.   fprintf(stderr,"\nAborting rolodex, no changes since last save recorded\n");
  142.   exit(-1);  
  143. }  
  144.  
  145.  
  146. user_eof ()
  147.  
  148. /* if the user hits C-D */
  149.  
  150. {
  151. #ifdef VMS
  152.   delete(homedir(ROLOLOCK));
  153. #else
  154.   unlink(homedir(ROLOLOCK));        
  155. #endif
  156.   fprintf(stderr,"\nUnexpected EOF on terminal. Saving rolodex and exiting\n");
  157.   save_and_exit(-1);        
  158. }
  159.  
  160.  
  161. roloexit (rval) int rval;
  162. {
  163.   /* In case it hasn't been cleaned up, also clobber ROLOTEMP. */
  164.   clear_the_screen();
  165.   if (rololocked)
  166. #ifdef VMS
  167.   delete(homedir(ROLOTEMP));
  168.   delete(homedir(ROLOLOCK));
  169.   exit(rval==0?1:rval);
  170. #else
  171.   unlink(homedir(ROLOTEMP));
  172.   unlink(homedir(ROLOLOCK));
  173.   exit(rval);
  174. #endif
  175. }  
  176.       
  177.                                       
  178. save_to_disk ()
  179.  
  180. /* move the old rolodex to a backup, and write out the new rolodex and */
  181. /* a copy of the new rolodex (just for safety) */
  182.  
  183. {
  184.   FILE *tempfp,*copyfp;        
  185.   char *strcpy();
  186.   char d1[DIRPATHLEN], d2[DIRPATHLEN];
  187.  
  188. #ifdef VMS
  189.   /*
  190.    * Since VMS keeps versions of files around, clobber any that are still
  191.    * hanging around.  If appropriate access permissions aren't granted,
  192.    * well, they'll just have to purge their directory...
  193.    */
  194.   delete(homedir(ROLOTEMP));    /* There will be a copy of this from earlier */
  195.  
  196.   if(!access(homedir(ROLOCOPY),R_OK))
  197.     if(!access(homedir(ROLOCOPY),W_OK))    /* Implies delete permission */
  198.     delete(homedir(ROLOCOPY));
  199. #endif
  200.   tempfp = fopen(homedir(ROLOTEMP),"w");
  201.   if(tempfp == (FILE *)NULL)
  202.      perror(ROLOTEMP);
  203.  
  204.   copyfp = fopen(homedir(ROLOCOPY),"w");
  205.   if(copyfp == (FILE *)NULL)
  206.      perror(ROLOCOPY);
  207.  
  208.   if (tempfp == (FILE *)NULL || copyfp == (FILE *)NULL) {
  209.      fprintf(stderr,"Unable to write rolodex...\n");
  210.      fprintf(stderr,"Any changes made have not been recorded\n");
  211.      roloexit(-1);
  212.   }
  213.  
  214.   /*
  215.    * Be sure to set proper permissions on the temp,copy files *before* putting
  216.    * data in them...
  217.    */
  218. #ifndef MSDOS
  219.   if(chmod(homedir(ROLOTEMP),(int)stat_buf.st_mode))
  220.     fprintf(stderr,"WARNING: Couldn't set permissions on %s\n",
  221.         homedir(ROLOTEMP));
  222.  
  223.   if(chmod(homedir(ROLOCOPY),(int)stat_buf.st_mode))
  224.     fprintf(stderr,"WARNING: Couldn't set permissions on %s\n",
  225.         homedir(ROLOCOPY));
  226. #endif    /* MSDOS */
  227.  
  228.   write_rolo(tempfp,copyfp);
  229.   
  230.   fclose(tempfp);    
  231.   fclose(copyfp);
  232.  
  233. #ifdef UNIX
  234.   unlink(strcpy(d1,homedir(ROLOBAK)));              
  235.   link(strcpy(d1,homedir(ROLODATA)),strcpy(d2,homedir(ROLOBAK)));
  236.   unlink(strcpy(d1,homedir(ROLODATA)));
  237.  
  238.   if(link(strcpy(d1,homedir(ROLOTEMP)),strcpy(d2,homedir(ROLODATA))))
  239.   {
  240.         fprintf(stderr,"Link failed.  Revised rolodex is in %s\n",ROLOCOPY);
  241.     roloexit(-1);
  242.   }else
  243.   {
  244.        unlink(strcpy(d1,homedir(ROLOTEMP)));
  245.        unlink(strcpy(d1,homedir(ROLOCOPY)));
  246.   }
  247. #endif
  248.  
  249. #ifdef VMS
  250.   delete(homedir(ROLOBAK));
  251.  
  252.   if ((rename(strcpy(d1,homedir(ROLODATA)),strcpy(d2,homedir(ROLOBAK))) != 1) ||
  253.       (rename(strcpy(d1,homedir(ROLOTEMP)),strcpy(d2,homedir(ROLODATA)))) != 1) {
  254.      fprintf(stderr,"Rename failed.  Revised rolodex is in %s\n",ROLOCOPY);
  255.      roloexit(-1);
  256.   }else
  257.     delete(homedir(ROLOCOPY));    /* Don't really need this anymore */
  258. #endif
  259.  
  260. #ifdef MSDOS
  261.   unlink(homedir(ROLOBAK));
  262.  
  263.   if (rename(strcpy(d1,homedir(ROLODATA)),strcpy(d2,homedir(ROLOBAK))) ||
  264.       rename(strcpy(d1,homedir(ROLOTEMP)),strcpy(d2,homedir(ROLODATA)))) {
  265.      fprintf(stderr,"Rename failed.  Revised rolodex is in %s\n",ROLOCOPY);
  266.      perror(homedir(ROLODATA));
  267.      perror(homedir(ROLOBAK));
  268.      perror(homedir(ROLOTEMP));
  269.      roloexit(-1);
  270.   }else
  271.     unlink(homedir(ROLOCOPY));    /* Don't really need this anymore */
  272. #endif
  273.  
  274.   printf("Rolodex saved\n");
  275.  
  276.   sleep(1);
  277.   changed = 0;
  278.   name_changed = 0;
  279. }
  280.                    
  281.  
  282. save_and_exit (rval) int rval;
  283. {
  284.   if (changed)
  285.     save_to_disk();
  286.   else
  287. #ifdef VMS
  288.     delete(homedir(ROLOTEMP));
  289. #endif
  290. #ifdef UNIX
  291.     unlink(homedir(ROLOTEMP));
  292. #endif
  293. #ifdef MSDOS
  294.     unlink(homedir(ROLOTEMP));
  295. #endif
  296.  
  297.   roloexit(rval);        
  298. }
  299.                  
  300. #ifdef UNIX
  301. extern struct passwd *getpwnam();
  302.  
  303. char *home_directory (name) char *name;
  304. {
  305.   struct passwd *pwentry;
  306.   if (0 == (pwentry = getpwnam(name))) return("");
  307.   return(pwentry -> pw_dir);
  308. }
  309. #endif
  310.  
  311. #ifdef VMS
  312. /*
  313.  * This routine should never be called in VMS.
  314.  */
  315. char *home_directory(name) char *name;
  316. {
  317.     fprintf(stderr,"INTERNAL ERROR: Called home_directory under VMS.\n");
  318.     exit(0);
  319. }
  320. #endif
  321.  
  322. #ifdef MSDOS
  323. /*
  324.  * This is rather simplistic. For drives A through C, try to find a directory
  325.  * named 'name' under the root.  If not found on any of the drives, then
  326.  * simply return the root directory of the current drive.
  327.  */
  328. char *home_directory (name) char *name;
  329. {
  330.     char *drvspec = "A:\\";
  331.  
  332.     static char dirbuff[128];
  333.     int fid;
  334.  
  335.     for(;*drvspec <= 'C';(*drvspec)++)
  336.     {
  337.         strcpy(dirbuff,drvspec);
  338.         strcat(dirbuff,name);
  339.         
  340.         if((fid = open(dirbuff,O_RDONLY)) >= 0)
  341.         {
  342.             close(fid);
  343.             return(dirbuff);
  344.         }else
  345.             if(errno != ENOENT && errno != ENODEV)
  346.                 return(dirbuff);
  347.     }
  348.  
  349.           return("/");
  350. }                       
  351. #endif
  352.  
  353. char *homedir (filename) char *filename;
  354.  
  355. /* e.g., given "rolodex.dat", create "/u/massar/rolodex.dat" */
  356. /* rolodir generally the user's home directory but could be someone else's */
  357. /* home directory if the -u option is used. */
  358.  
  359. {
  360. #ifdef UNIX
  361.   nbuffconcat(filebuf,3,rolodir,"/",filename);
  362. #endif
  363.  
  364. #ifdef MSDOS
  365.   nbuffconcat(filebuf,3,rolodir,"\\",filename);
  366. #endif
  367.  
  368. #ifdef VMS
  369.   nbuffconcat(filebuf,2,rolodir,filename);
  370. #endif
  371.  
  372.   return(filebuf);
  373. }
  374.  
  375.  
  376. char *libdir (filename) char *filename;
  377.  
  378. /* return a full pathname into the rolodex library directory */
  379. /* the string must be copied if it is to be saved! */
  380.  
  381. {
  382. #ifdef UNIX
  383.   nbuffconcat(filebuf,3,ROLOLIB,"/",filename);
  384. #endif
  385.  
  386. #ifdef MSDOS
  387.   /*
  388.    * If there's no drive specifier in ROLOLIB, then prepend the current
  389.    * drive.
  390.    */
  391.   char *curdir;
  392.   char *getcwd();
  393.  
  394.   curdir = ROLOLIB;
  395.  
  396.   if(curdir[2] != ':')
  397.   {
  398.       curdir = getcwd((char *)NULL,128);
  399.     curdir[3] = '\0';
  400.     nbuffconcat(filebuf,4,curdir,ROLOLIB,"\\",filename);
  401.     (void)free(curdir);
  402.   }else
  403.     nbuffconcat(filebuf,3,ROLOLIB,"\\",filename);
  404. #endif
  405.  
  406. #ifdef VMS
  407.   nbuffconcat(filebuf,2,ROLOLIB,filename);
  408. #endif
  409.  
  410.                  
  411.   return(filebuf);        
  412. }
  413.  
  414.  
  415. rolo_only_to_read () 
  416. {
  417.   return((option_present(READONLYFLAG) << 1) |
  418.     (option_present(SUMMARYFLAG) || n_non_option_args()));
  419. }
  420.  
  421.  
  422. locked_action () 
  423. {
  424.   if (option_present(OTHERUSERFLAG)) {        
  425.      fprintf(stderr,"Someone else is modifying that rolodex, sorry\n");
  426.      exit(-1);
  427.   }
  428.   else {
  429.      cathelpfile(LOCKINFO,"locked rolodex",0);
  430.      exit(-1);
  431.   }
  432. }  
  433.   
  434.  
  435. pretty_print()
  436. {
  437.     int elt_lines, index, tmp_line_cnt;
  438.     int line_cnt = 0;
  439.     char *tmpptr;
  440.     char *strchr();
  441.     FILE *lstfp;
  442.     Ptr_Rolo_List rptr;
  443.     Ptr_Rolo_Entry lentry;
  444.  
  445.     clear_the_screen();
  446.  
  447.     fputs("\nPretty printing the Rolodex...\n",stdout);
  448.     fprintf(stdout,"Print the file %-30s\n", homedir(ROLOPRINT));
  449.  
  450.     lstfp = fopen(homedir(ROLOPRINT),"w");
  451.     if(lstfp == (FILE *)NULL) {
  452.         perror(homedir(ROLOPRINT));
  453.         return;
  454.     }
  455.  
  456.     rptr = Begin_Rlist;
  457.     if(rptr == 0) {
  458.         fputs("\n\nNo entries to print...\n",stderr);
  459.         return;
  460.     }
  461.  
  462.     while (rptr != 0) {
  463.           lentry = get_entry(rptr);
  464.  
  465.         /* Find the number of lines this entry requires to print */
  466.         for(elt_lines = 0, index = 0; index < N_BASIC_FIELDS; index++) {
  467.             tmpptr = lentry->basicfields[index];
  468.             elt_lines++;    /* Even one for an empty line */
  469.  
  470.             while((tmpptr = strchr(tmpptr,';')) != (char *)NULL) {
  471.                 elt_lines++;
  472.                 tmpptr++;
  473.             }
  474.         }
  475.         if(lentry->n_others) {
  476.             for(index=0; index < lentry->n_others; index++) {
  477.                 elt_lines++;    /* As above, even if the entry is empty... */
  478.                 tmpptr = lentry->other_fields[index];
  479.                             
  480.                             while((tmpptr = strchr(tmpptr,';')) != (char *)NULL) {
  481.                                 elt_lines++;
  482.                                 tmpptr++;
  483.                             }
  484.             }
  485.         }
  486.  
  487.         /*
  488.          * Check to see if there is enough room on the current page
  489.          * to print this entry... Otherwise advance to the top of the
  490.          * next page
  491.          */
  492.         tmp_line_cnt = line_cnt + elt_lines;
  493.         if(tmp_line_cnt > MAX_LINES) {
  494.             fputc('\f',lstfp);
  495.             line_cnt = 0;
  496.         }
  497.  
  498.         /*
  499.          * We can now start the printing of the actual entry
  500.          */
  501.         fputs("Name:               ",lstfp);
  502.         prt_dump(get_basic_rolo_field((int)R_NAME,lentry),lstfp,20);
  503.         fputs("Home address:       ",lstfp);
  504.         prt_dump(get_basic_rolo_field((int)R_HOME_ADDRESS,lentry),lstfp,20);
  505.         fputs("Home phone:         ",lstfp);
  506.         prt_dump(get_basic_rolo_field((int)R_HOME_PHONE,lentry),lstfp,20);
  507.         fputs("Company:            ",lstfp);
  508.         prt_dump(get_basic_rolo_field((int)R_COMPANY,lentry),lstfp,20);
  509.         fputs("Work address:       ",lstfp);
  510.         prt_dump(get_basic_rolo_field((int)R_WORK_ADDRESS,lentry),lstfp,20);
  511.         fputs("Work phone:         ",lstfp);
  512.         prt_dump(get_basic_rolo_field((int)R_WORK_PHONE,lentry),lstfp,20);
  513.         fputs("Remarks:            ",lstfp);
  514.         prt_dump(get_basic_rolo_field((int)R_REMARKS,lentry),lstfp,20);
  515.  
  516.         /* Now print any user defined fields */
  517.         if(lentry->n_others) {
  518.             fputs("*** User defined fields ***\n",lstfp);
  519.             line_cnt++;
  520.             for(index = 0;index < lentry->n_others; index++)
  521.                 fprintf(lstfp,"%-30s\n",get_other_field(index,lentry));
  522.         }
  523.  
  524.         /* Print the date this entry was last updated */
  525.         fputs("                LAST UPDATED:       ",lstfp);
  526.         prt_dump(get_basic_rolo_field((int)R_UPDATED,lentry),lstfp,20);
  527.  
  528.         /* Print two(2) blank lines, and increment the line count */
  529.         fputs("\n\n",lstfp);
  530.         line_cnt += elt_lines;
  531.         line_cnt += 2;        /* For the two blank lines between entries */
  532.         rptr = get_next_link(rptr);
  533.     }
  534.     fclose(lstfp);
  535. }
  536.  
  537. prt_dump(strptr, stream, offset)
  538. char *strptr;
  539. FILE *stream;
  540. int offset;
  541. {
  542.     int i;
  543.  
  544.     if(*strptr == (char)NULL)
  545.         fputs("<<NONE>>\n",stream);
  546.     else {
  547.         for(; *strptr != '\0'; strptr++) {
  548.             if(*strptr == ';') {
  549.                 fputc('\n',stream);
  550.                 for(i = 0; i < offset; i++)
  551.                     fputc(' ',stream);
  552.             }
  553.             else
  554.                 fputc(*strptr,stream);
  555.         }
  556.         fputc('\n',stream);
  557.     }
  558. }
  559.  
  560. main (argc,argv) int argc; char *argv[];
  561.  
  562. {
  563.     int fd,in_use,rolofd;
  564.     Bool not_own_rolodex;        
  565.     char *user = "";
  566.     FILE *tempfp;
  567.     
  568.     clearinit();
  569.     clear_the_screen();
  570.     
  571.     /* parse the options and arguments, if any */
  572.     
  573.     switch (get_args(argc,argv,T,T)) {
  574.         case ARG_ERROR : 
  575.           roloexit(-1);
  576.         case NO_ARGS :
  577.           break;
  578.         case ARGS_PRESENT :
  579.           if (ALL_LEGAL != legal_options(LEGAL_OPTIONS)) {
  580.                 fprintf(stderr,"illegal option\nusage: %s\n",USAGE);
  581.                 roloexit(-1);
  582.           }
  583.     }
  584.     
  585.     /* find the directory in which the rolodex file we want to use is */
  586.     
  587.     not_own_rolodex = option_present(OTHERUSERFLAG);        
  588.     if (not_own_rolodex) {
  589.        if (NIL == (user = option_arg(OTHERUSERFLAG,1)) || 
  590.            n_option_args(OTHERUSERFLAG) != 1) {
  591.           fprintf(stderr,"Illegal syntax using -u option\nusage: %s\n",USAGE);
  592.           roloexit(-1);
  593.        }
  594.     }        
  595. #ifndef MSDOS
  596.     else {
  597.        if (0 == (user = getenv("HOME"))) {
  598.           fprintf(stderr,"Cant find your home directory, no HOME\n");
  599.           roloexit(-1);
  600.        }
  601.     }
  602. #endif
  603.     if (not_own_rolodex) {
  604. #ifndef MSDOS
  605.        strcpy(rolodir,user);
  606. #else
  607.        strcpy(rolodir,home_directory(user));
  608. #endif
  609.        if (*rolodir == '\0') {
  610.           fprintf(stderr,"No user %s is known to the system\n",user);
  611.           roloexit(-1);
  612.        }
  613.     }
  614.     else strcpy(rolodir,user);
  615.     
  616.     /* is the rolodex readable? */
  617.     
  618.     if (0 != access(homedir(ROLODATA),R_OK)) {
  619.         
  620.        /* No.  if it exists and we cant read it, that's an error */
  621.         
  622.        if (0 == access(homedir(ROLODATA),F_OK)) { 
  623.           fprintf(stderr,"Cant access rolodex data file to read\n");
  624.           roloexit(-1);
  625.        }
  626.        
  627.        /* if it doesn't exist, should we create one? */
  628.        /* Under Unix, only if it's our own.  On other systems, it depends.*/
  629.  
  630. #ifdef UNIX       
  631.        if (option_present(OTHERUSERFLAG)) {
  632.           fprintf(stderr,"No rolodex file belonging to %s found\n",user);
  633.           roloexit(-1);
  634.        }
  635. #endif
  636.        /* try to create it, only if its our own */
  637.        
  638.        if (-1 == (fd = creat(homedir(ROLODATA),DEF_PERM))) {
  639.          if(option_present(OTHERUSERFLAG))
  640.        fprintf(stderr,"couldn't create rolodex in %s\n",homedir(ROLODATA));
  641.      else
  642.            fprintf(stderr,"couldn't create rolodex in your home directory\n");
  643.  
  644.          roloexit(-1);
  645.        }      
  646.        
  647.        else {
  648.      stat_buf.st_mode = DEF_PERM;    /* For later mode set */
  649.          close(fd);
  650.          fprintf(stderr,"Creating empty rolodex...\n");
  651.        }
  652.  
  653.     }
  654.     
  655.     /* see if someone else is using it */
  656.     
  657.     in_use = (0 == access(homedir(ROLOLOCK),F_OK));
  658.     
  659.     /* are we going to access the rolodex only for reading? */
  660.     
  661.     if (!(read_only = rolo_only_to_read())) {
  662.     
  663.        /* No.  Make sure no one else has it locked. */
  664.         
  665.        if (in_use) {
  666.           locked_action();
  667.        }
  668.         
  669.        /* create a lock file.  Catch interrupts so that we can remove */
  670.        /* the lock file if the user decides to abort */
  671.                
  672.        if (!option_present(NOLOCKFLAG)) {
  673.           if ((fd = open(homedir(ROLOLOCK),O_EXCL|O_CREAT,00200|00400)) < 0) {
  674.              fprintf(stderr,"unable to create lock file...\n");
  675. #ifdef VMS
  676.          exit(0);
  677. #else
  678.          exit(1);
  679. #endif
  680.       }
  681.           rololocked = 1;
  682.           close(fd);
  683. #ifdef MSDOS
  684. #    ifdef MSC
  685.       signal(SIGINT,user_interupt);
  686. #    else
  687.       ssignal(SIGINT,user_interrupt);    /* Very Turbo-ish */
  688. #    endif    /* MSC */
  689. #else
  690.           signal(SIGINT,user_interrupt);
  691. #endif
  692.        }
  693.         
  694.        /* open a temporary file for writing changes to make sure we can */
  695.        /* write into the directory */
  696.        
  697.        /* when the rolodex is saved, the old rolodex is moved to */
  698.        /* a '~' file (on Unix), the temporary is made to be the new rolodex, */
  699.        /* and a copy of the new rolodex is made */
  700.        
  701.        if (NULL == (tempfp = fopen(homedir(ROLOTEMP),"w"))) {
  702.            fprintf(stderr,"Can't open temporary file to write to\n");
  703.            roloexit(-1);
  704.        }        
  705.        fclose(tempfp);
  706.     
  707.     }
  708.        
  709.     allocate_memory_chunk(CHUNKSIZE);
  710.     
  711.     if (NULL == (rolofd = open(homedir(ROLODATA),O_RDONLY))) {
  712.         fprintf(stderr,"Can't open rolodex data file to read\n");
  713.         roloexit(-1);
  714.     }
  715.     
  716.     /* Get the current rolodex file's permissions */
  717.     if(fstat(rolofd,&stat_buf))
  718.     {
  719.     fprintf(stderr,"Can't fstat rolodex data file\n");
  720.     roloexit(-1);
  721.     }
  722.  
  723.     /* read in the rolodex from disk */
  724.     /* It should never be out of order since it is written to disk ordered */
  725.     /* but just in case... */
  726.     
  727.     if (!(read_only & 1)) printf("Reading in rolodex from %s\n",homedir(ROLODATA));
  728.     read_rolodex(rolofd);
  729.     close(rolofd);
  730.     if (!(read_only & 1)) printf("%d entries listed\n",rlength(Begin_Rlist));
  731.     if (reorder_file && !read_only) {
  732.        fprintf(stderr,"Reordering rolodex...\n");
  733.        rolo_reorder();
  734.        fprintf(stderr,"Saving reordered rolodex to disk...\n");
  735.        save_to_disk();
  736.     }
  737.        
  738.     /* the following routines live in 'options.c' */
  739.     
  740.     /* -s option.  Prints a short listing of people and phone numbers to */
  741.     /* standard output */
  742.     
  743.     if (option_present(SUMMARYFLAG)) {
  744.         print_short();
  745. #ifdef VMS
  746.         exit(1);
  747. #else
  748.         exit(0);         
  749. #endif 
  750.     }
  751.     
  752.     /* rolo <name1> <name2> ... */
  753.     /* print out info about people whose names contain any of the arguments */
  754.     
  755.     if (n_non_option_args() > 0) {
  756.        print_people();
  757. #ifdef VMS
  758.        exit(1);
  759. #else
  760.        exit(0);
  761. #endif
  762.     }
  763.     
  764.     /* regular rolodex program */
  765.     
  766.     interactive_rolo();
  767. #ifdef VMS
  768.     exit(1);
  769. #else
  770.     exit(0);
  771. #endif
  772.     
  773. }
  774.  
  775. #ifdef MSC
  776. sleep(sec)
  777. int sec;
  778. {
  779.     register long tloc;
  780.     long time();
  781.  
  782.     tloc = time((long *)NULL);
  783.  
  784.     tloc += (long)sec;
  785.  
  786.     while(time((long *)NULL) <= tloc);
  787.  
  788.     return(0);
  789. }
  790. #endif
  791.