home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / msdos / c / crcbbs.arc / CRCPC1B.C < prev    next >
Encoding:
C/C++ Source or Header  |  1985-10-22  |  20.9 KB  |  759 lines
  1. #include    "crcpchdr.h"
  2.  
  3. int fork_board(c,args,opts)
  4. char c, *args, *opts;
  5. {
  6. char *type;
  7. int rc;
  8.  
  9. if (!fork_allowed) {
  10.     printf("Sorry, this command has been disabled.\r\n");
  11.     return(99);
  12.     }
  13. if (!*args && beginner && !find_option(opts,'q')) disp_msg(16);
  14. if (no_account) {
  15.     printf("You must first obtain an account before\r\n");
  16.     printf("using this command.  See <A> command at main menu.\r\n");
  17.     return(99);
  18.     }
  19. if (*args) {
  20.     stptok(args,workstr,9," ");
  21.     goto tryth1;
  22.     }
  23. getdnagn:
  24. if (*args) return(1000);
  25. disp_reply("Enter name for new message board:  ",workstr,9);
  26. if (!workstr[0]) return(nothing_done()&0);
  27. tryth1:     
  28. if (type=stpbrk(workstr,INVDOSFNCHR)) {
  29.      bad_dn(*type);
  30.      goto getdnagn;
  31.      }
  32. uppercase(workstr);
  33. if (!sysdir(workstr,user_root)) {
  34.      printf("There exists a user '%s' on the system.  Use another name.r\n",workstr);
  35.         goto getdnagn;
  36.     }
  37. else if (!sysdir(workstr,MESSAGES)) {
  38.      printf("There already exists a '%s' board!\r\n",workstr);
  39.         goto getdnagn;
  40.     }
  41. printf("Standby:\r\n");
  42.         /* Rc==2 when using -XT (??) */
  43. if ((rc=sysmkdir(workstr,MESSAGES)) && rc!=2) {
  44.     printf("Oops!  Error during directory creation.\r\n");
  45.     printf("Not today: sorry.\r\n");
  46.     sprintf(file_buff,"MESSAGE BOARD '%s' CREATION BY %s FAILED: RC=%d",
  47.         workstr,user_id,rc);
  48.     logevent(file_buff);
  49.     }
  50. else {
  51.     printf("Ok %s, message directory '%s' created and ready for use.\r\n",
  52.         usname(),workstr);
  53.     sprintf(file_buff,"MESSAGE BOARD '%s' CREATED BY %s",workstr,user_id);
  54.     logevent(file_buff);
  55.     }
  56. return(0);
  57. }
  58.  
  59. kill_board(c,args,opts)
  60. char c, *args, *opts;
  61. {
  62. int gnl_flag;
  63. char *type;
  64.  
  65. if (!fork_allowed) {
  66.     printf("Sorry, this command has been disabled.\r\n");
  67.     return;
  68.     }
  69. if (!*args && !find_option(opts,'q') && beginner) disp_msg(17);
  70. if (no_account) {
  71.     printf("You must first obtain an account before\r\n");
  72.     printf("using this command.  See <A> command at main menu.\r\n");
  73.     return;
  74.     }
  75.  
  76. if (*args) {
  77.     stptok(args,workstr,9," ");
  78.     goto tryth2;
  79.     }
  80.  
  81. g2tdnagn:
  82. if (*args) return;
  83. printf("Enter name of message board to kill:  ");
  84. strcpy(workstr,lineinput(9));
  85. if (!workstr[0]) return(nothing_done());
  86. tryth2:
  87. if (type=stpbrk(workstr,INVDOSFNCHR)) {
  88.     bad_dn(*type);
  89.     goto g2tdnagn;
  90.     }
  91. uppercase(workstr);
  92. if (sysdir(workstr,MESSAGES)) {
  93.     printf("No such board.\r\n");
  94.     return;
  95.     }
  96. else if (!setup_dir("*.*",FILE_TYP)) {
  97.     printf("Directory '%s' has files in it!\r\n",workstr);
  98.     return;
  99.     }
  100. printf("Please wait; this takes awhile sometimes...\r\n");
  101. sysdir("",MESSAGES);
  102. if (gnl_flag=sysrmdir(workstr,MESSAGES)) {
  103.     if (gnl_flag==5) {
  104.         printf("'%s' has files in it!\r\n",workstr);
  105.         return;
  106.         }
  107.     else if (gnl_flag==3) printf("No such board: '%s'!\r\n",workstr);
  108.     goto g2tdnagn;
  109.     }
  110. else {
  111.     printf("Ok %s, message board '%s' has been removed.\r\n",usname(),workstr);
  112.     sprintf(file_buff,"MESSAGE BOARD %s REMOVED BY %s",workstr,user_id);
  113.     logevent(file_buff);
  114.     }
  115. }
  116.  
  117. msg_sys(c,args,opts)
  118. char c, *args, *opts;
  119. {
  120. char messtyp[15];
  121. int quiet, ags;
  122.  
  123. ags = (*args);
  124. quiet = find_option(opts,'q');
  125. do {
  126.     if (sysdir("",MESSAGES)) {
  127.         printf("Cannot access message tree: %s.\r\n",MESSAGES);
  128.         return;
  129.         }
  130.     else {
  131.         if (beginner && !quiet && !*args) {
  132.             mputs("Enter the name of a system message board.\r\n");
  133.             mputs("For a list of current message boards, type <*>, or <ENTER> to quit\r\n");      
  134.             cr();
  135.             }
  136. brdlist:
  137.         if (!*args) disp_reply("Message board? ",boardname,9);
  138.         else args = stpblk(stptok(args,boardname,9," "));
  139.         while(boardname[0]=='*') {   
  140.             dir("*.*",DIR_TYP);
  141.             disp_reply("Message board? ",boardname,9);
  142.             }
  143.         if (boardname[0]) {
  144.             if (sysdir(boardname,MESSAGES)) 
  145.                 printf("Message board '%s' not found.\r\n",boardname);
  146.             else {
  147.                 if (wildcards) {
  148.                     if (!*args) {
  149.                         if (beginner && !quiet) {
  150.                             mputs("You may use UNIX, and CP/M style 'wildcards' which are\r\n");
  151.                             mputs("used in selecting the messages you access.  The filename\r\n");
  152.                             mputs("is the name of the sender, the extension is msg #.\r\n");
  153.                             }
  154.                         disp_reply("Enter wildcard or press <ENTER>: ",messtyp,9);
  155.                         }
  156.                     else args = stpblk(stptok(args,messtyp,9," "));
  157.                     if (messtyp[0]=='\0') strcpy(messtyp,"*.*");
  158.                     else if (stpchr(messtyp,'.')==NULL) strcat(messtyp,".*");
  159.                     }
  160.                 else strcpy(messtyp,"*.*");
  161.                 msgdir(boardname,messtyp,args,opts);
  162.                 }
  163.             }
  164.         }
  165.     } while(boardname[0] && !ags);
  166. }
  167.  
  168.  
  169. /* MOVETOBOARD:  We are logged onto the BOARD directory we want a users file 
  170.          to go to.  First, we determine the message number, then copy it.
  171.                                     */
  172. static movetoboard(bname,fname,udir)
  173. char bname[];
  174. char fname[];
  175. char udir[];
  176. {
  177.     int rc;
  178.     int lm;
  179.     char sourcen[15];
  180.     char extn[5];
  181.     char newdir1[40];
  182.     char newdir2[33];
  183.  
  184.     if (rc=setup_dir("*.*",FILE_TYP)) lm = 1;    /* Setup for msg scan */
  185.     else {
  186.         create_list();            /* Create memory array from names */
  187.         sort_list(list,list_idx);    /* Sort the names */
  188.         lm = list[list_idx-1]->value+1;
  189.         drop_list();
  190.         }
  191.  
  192.     strcpy(sourcen,user_id);     /* Get senders name as filename */
  193.     sprintf(extn,".%d",lm);        /* Next avail. msg # */
  194.     strcat(sourcen,extn);        /* Create filename */
  195.  
  196.     prefix_dir(newdir1,bname,MESSAGES);
  197.     prefix_dir(newdir2,udir,user_root);
  198.         
  199.                         /*  text,create */
  200.     if (!sysfcopy(newdir1,sourcen,newdir2,fname,TRUE,TRUE)) {
  201.         printf("Msg %d saved into %s message board.\r\n",lm,bname);
  202.         sprintf(newdir1,"%s POSTED MSG#%d TO %s",user_id,lm,bname);
  203.         logevent(newdir1);
  204.         }
  205. }
  206.  
  207.  
  208.  
  209. /*****************************************************************************
  210.  *  MSGDIR:  Perform disk directory into string array.  Sort array, then     *
  211.  *         goto user with sorted list, allowing access to files in list.   *
  212.  *****************************************************************************/
  213. static int msgdir(board,fn,args,opts)
  214. char board[];
  215. char *fn ;               
  216. char *args, *opts;
  217. {
  218.     int rc;
  219.     int lastmsg;
  220.     int mo,dy,yr;
  221.  
  222.     sysdate(&mo,&dy,&yr);
  223.     uppercase(board);
  224.     if (sysdir(board,MESSAGES)) return(baddir(board));
  225.  
  226.     if (rc=setup_dir(fn,FILE_TYP)) ;
  227.     else {
  228.         create_list();            /* Create memory array from names */
  229.         sort_list(list,list_idx);    /* Sort the names */
  230.         lastmsg = l_u_msg(board);    /* Find out where he was */
  231.         if (!strcmp(fn,"*.*") &&    /* If on entire board */
  232.              !no_account)           /* And user has account */
  233.             if (list[list_idx-1]->value==l_b_msg(board) && !find_option(opts,'q'))
  234.                 printf("No new messages.\r\n");
  235.         lastmsg = goto_user(lastmsg,board,fn,args,opts);
  236.         if (!strcmp(fn,"*.*") &&    /* If on entire board */
  237.              !no_account)        /* And user has account */
  238.             a_u_msg(board,list[list_idx-1]->value,lastmsg,mo,dy,yr);
  239.         drop_list();            /* Drop the names from memory */
  240.         }
  241.     return(rc);
  242. }
  243.  
  244.  
  245. static char *smsg_fnc(c)
  246. char c;
  247. {
  248. switch(c) {
  249.     case 'W': return("WSCAN");
  250.     case 'R': return("READ");
  251.     case 'S': return("SCAN");
  252.     case 'D': return("DELETE");
  253.     }
  254. return("");
  255. }
  256.  
  257. /* NOTE:  LIST_IDX is defined as being positive during thes routines ! */
  258. static int next_midx(msgnum)
  259. int msgnum;
  260. {
  261. int i;
  262. for (i=0;i<list_idx;++i) if (list[i]->value>msgnum) break;    
  263. return(i<list_idx?i:-1);
  264. }
  265.  
  266.  
  267. /* NEXT_IDX: We search forward or backward until finding non deleted filename */
  268. /* Return "-1" if not found */
  269. static int next_idx(sidx,dir)
  270. int sidx;
  271. int dir;
  272. {
  273. for (sidx+=dir;sidx>=0 && sidx<list_idx;sidx+=dir)
  274.     if (list[sidx]->filedata.filename_char[0]!='*'&&list[sidx]->value) break;
  275. return((sidx>=0 && sidx<list_idx)?sidx:-1);
  276. }
  277.  
  278. /*****************************************************************************
  279.  *  FIRST_IDX:   Find index to first file number in array.                   *
  280.  *         Returns "-1" if no data in array.                               *
  281.  *****************************************************************************/
  282. static int first_idx()
  283. {
  284. return(next_midx(0));
  285. }
  286.  
  287. /*****************************************************************************
  288.  *  FIND_IDX:   Find index to corresponding file number in the array.        *
  289.  *         Return index to indicated file number, else -1 for not found.   *
  290.  *****************************************************************************/
  291. static int find_idx(msgnum)
  292. int msgnum;
  293. {
  294.     int i;
  295.  
  296.     if ((i=first_idx())!=-1) 
  297.         while(i<list_idx) 
  298.             if (list[i]->value==msgnum)    return(i);
  299.                              else i++;
  300.     return (-1);
  301. }
  302.  
  303.  
  304. /* Returns '0' if no message files in array, else first message number */
  305. static int first_msg()
  306. {
  307. int ans;
  308. ans = list_idx ? list[first_idx()]->value : 0; 
  309. return(ans);
  310. }
  311.  
  312.  
  313. /* Returns '0' if no message files in array, else last message number */
  314. static int last_msg() 
  315. { 
  316. int ans;
  317. ans = list_idx ? list[list_idx-1]->value : 0;
  318. return(ans);
  319. }
  320.  
  321.  
  322. /* Returns '0' if no message files in array, else number of messages in array */
  323. /* NOTE: The result of this routine is incorrect if any 'deleted' files exist */
  324. /*       in the array                                    */
  325. static int tot_msg() 
  326. { 
  327. int ans;
  328. ans = list_idx ? list_idx-first_idx() : 0;
  329. return(ans);
  330. }
  331.  
  332. /*****************************************************************************
  333.  *  GOTO_USER:  We have a sorted list of file entries in the string array.   *
  334.  *         We present an acceptable method of accessing these files here.  *
  335.  *****************************************************************************/
  336. static int goto_user(lstusrmsg,board,filter,args,opts)
  337. int lstusrmsg;
  338. char board[];
  339. char filter[];
  340. char *args, *opts;
  341. {
  342.     char c;
  343.     int mode;
  344.     int index;
  345.     int alt_index;
  346.     int alt_msg;
  347.     int quiet;
  348.     int firstmsgnum, lastmsgnum, totmsgs;
  349.     char fromwho[9];
  350.     char token[LINESIZE+2];
  351.     char *parseptr;
  352.     char string[LINESIZE+2];
  353.  
  354. quiet = find_option(opts,'q');
  355. quit = FALSE;
  356. firstmsgnum = first_msg();
  357. lastmsgnum = last_msg();
  358.  
  359. if (!list_idx || !lastmsgnum) {
  360.     printf("No messages (%s) on %s board.\r\n",filter,board);
  361.     return(0);
  362.     }
  363.  
  364.         /* Get index to next msg */
  365. if ((index=next_midx(lstusrmsg)==-1)) index=list_idx-1;    /* In case not found */
  366. totmsgs = tot_msg();
  367.  
  368.  
  369. if (totmsgs>1) strcpy(string,"s");
  370. else string[0] = '\0';
  371. printf("%d message%s (%s) on %s: %d-%d\r\n",totmsgs,string,filter,board,firstmsgnum,lastmsgnum);
  372. do {
  373.     output = TRUE;
  374.     if (!*args) {
  375.         if (!quiet && beginner) {
  376.             mputs("--------------\r\n");
  377.             mputs("Message Access\r\n");
  378.             mputs("--------------\r\n");
  379.             cr();
  380.             mputs("Press <ENTER> to return to main level.\r\n");
  381.             }
  382.         printf("(%s: W,R,S,D,?): ",board);
  383.         c = *ltrim(lineinput(2));
  384.         }
  385.     else {
  386.         c = *args ;
  387.         args = skptok(args);
  388.         }
  389.  
  390.     if (c=toupper(c)) {
  391.         if (stpchr("WRSD?",c)==NULL) printf("? %c: type ? for help.\r\n",c);
  392.         else if (c=='?') help(SYSACC,opts);
  393.         else {
  394.             if (c!='D' && beginner && !quiet) msgaccinst(c,index);
  395.             do {
  396.                 get_name(fromwho,list[index]->filedata.filename_ext);
  397.                 quit = FALSE;
  398.                 if (beginner && !quiet) {
  399.                     sprintf(token,"Current message: %d\r\n",list[index]->value);
  400.                     mputs(token);
  401.                     }
  402.                 if (!*args) {
  403.                     if (beginner && !quiet) printf("Press <ENTER> to return.\r\n");
  404.                     sprintf(token,"(%s [%d-%d]: Y=%d, ?=help):  ",
  405.                         smsg_fnc(c),firstmsgnum,lastmsgnum,list[index]->value);
  406.                     mputs(token);
  407.                     strcpy(string,lineinput(LINESIZE));
  408.                     }
  409.                 else strcpy(string,args);
  410.                 output = TRUE;
  411.                 if (string[0]) index=perform_line(c,string,index,opts);
  412.                 } while (string[0] && index>=0 && !*args);
  413.             } /* End Else */
  414.         } /* End IF */
  415.     if (index<0) printf("All messages deleted.\r\n");
  416.     } while(c && index>=0 && !*args);
  417.  
  418.                         /* Point to last msg read */
  419. index = index==list_idx-1?index:index-1;
  420. index = chk_idx(index);
  421.  
  422. return(index<0?0:list[index]->value);
  423. }
  424.  /* End GOTO USER */
  425.  
  426. static int perform_line(c,string,index,opts)
  427. char c;
  428. char string[];
  429. int index;
  430. char *opts;
  431. {    
  432. int alt_index;
  433. int alt_msg;
  434. char token[LINESIZE+2];
  435. char *parseptr;
  436.  
  437. parseptr = stpblk(string);
  438. *parseptr = toupper(*parseptr);
  439.     /* Make 'FORWARD', 'REVERSE' and 'BACKWARD' work too */
  440. if (*parseptr=='F') *parseptr = '+';
  441. else if (*parseptr=='B' || *parseptr=='R') *parseptr = '-';
  442.  
  443. if (*parseptr=='Y') index=access(c,index,'+',1,opts);
  444. else if (*parseptr=='?') help(SYSMSG,opts);
  445. else if (*parseptr=='-'||*parseptr=='+') index=access(c,index,*parseptr,999,opts);
  446. else {
  447.     while(*parseptr && !quit && index>=0) {
  448.         parseptr = stptok(parseptr,token,sizeof(token)," ,#;:-+\n");
  449.         alt_msg = stoi(token);
  450.         if (!alt_msg) printf("Bad msg #%s\r\n",token);
  451.         else if (*stpblk(parseptr)=='+'||*stpblk(parseptr)=='-') {
  452.             parseptr = stpblk(parseptr);
  453.             if ((alt_index=next_midx(alt_msg-1))<0) msgnf(alt_msg);
  454.             else index=access(c,alt_index,*parseptr,999,opts);
  455.             }
  456.         else {
  457.             if ((alt_index=find_idx(alt_msg))<0) msgnf(alt_msg);    
  458.             else index=access(c,alt_index,'+',1,opts);
  459.             }
  460.         if (*parseptr) parseptr = stpblk(++parseptr);
  461.         } /* End While */
  462.     } /* End Else */
  463.                 /* Return index to NEXT msg to read, or "-1" */
  464. return(index);
  465. }
  466.  
  467.  
  468. static msgnf(mn)
  469. int mn;
  470. {
  471. printf("#%d not found.\r\n",mn);
  472. }
  473.  
  474. static int user_is_sure()
  475. {
  476.     char c;
  477.     
  478.     mputs("Enter <Y> if you are sure.  ");
  479.     c = *ltrim(lineinput(2));
  480.     return((toupper(c)=='Y'));
  481. }
  482.  
  483. static int access(function,index,direction,max,opts)
  484. char function;
  485. int index;
  486. char direction;
  487. int max;
  488. char *opts;
  489. {
  490. int inc;
  491. char filename[14];
  492. char workstr[LINESIZE];
  493. char fname[9];
  494. char c;
  495. int i;
  496. int gnl_flg;
  497. int ctr;
  498. int alt_index ;
  499.  
  500. for (ctr=0,inc=(direction=='-')?-1:1;ctr<max && 
  501.                     list_idx && 
  502.                         index>=first_idx() && 
  503.                         index<list_idx && 
  504.                         !quit;index+=inc,ctr++) {
  505.     if (bdos(KBHIT)) {
  506.         c = bdos(CONSINP);
  507.         c = toupper(c);
  508.         if (c==CTL_K || c=='K') {
  509.             quit = TRUE;
  510.             cr();
  511.             break;
  512.             }
  513.         else if (!c) local_function(bdos(CONSINP));
  514.         }
  515.     get_name(fname,list[index]->filedata.filename_ext);
  516.     if (fname[0]!='*') { /* Not been deleted */
  517.         if (function=='D') del_msg(uppercase(fname),index);
  518.         else if (function=='W') {    /* Wscan */
  519.             sprintf(workstr,"%d by %s on %s is %ld chars\r\n",
  520.                 list[index]->value,
  521.                 get_name(filename,list[index]->filedata.filename_ext),
  522.                 filedate(list[index]->filedata.file_date),
  523.                 (long)list[index]->filedata.file_size);
  524.             mputs(workstr);
  525.             }
  526.         else r_or_sc(index,function,fname,opts);  /* Read, or Scan */
  527.         }    /* End If (file not already deleted) */
  528.     }    /* End FOR */
  529.  
  530. index = chk_idx(index);        /* make sure dont go out of bounds on 'list' */
  531.  
  532. if (index>=0) {
  533.     if (list[index]->filedata.filename_ext[0]=='*') {
  534.         if ((alt_index=next_idx(index,inc))<0)
  535.             alt_index=next_idx(index,0-inc);
  536.         index = alt_index ;
  537.         }
  538.     }
  539.         /* Return INDEX TO NEXT msg to read in curdir, or "-1" */
  540. return(index);
  541. }
  542.     /* End ACCESS */
  543.  
  544. static int chk_idx(idx)
  545. int idx;
  546. {
  547. if (!list_idx) return(-1);
  548. if (idx<first_idx()) idx = first_idx();
  549. else if (idx>=list_idx) idx = list_idx-1;
  550. return(idx);
  551. }
  552.  
  553.  
  554. static r_or_sc(index,function,fname,opts)
  555. int index;
  556. char function;
  557. char fname[];
  558. char *opts;
  559. {
  560. FILE *path;
  561. int gnl_flag, i;
  562. char workstr[LINESIZE];
  563.  
  564. if ((path=fopen((*list[index]).filedata.filename_ext,"r"))==NULL) {
  565.     printf("Msg '%s' was deleted.\r\n",
  566.         list[index]->filedata.filename_ext);
  567.     }
  568. else {
  569.     switch(function) {
  570.         case 'R':
  571.             printf("Message #%d was ",list[index]->value);
  572.             printf("written by %s on %s at %s\r\n",
  573.                 fname,
  574.                 filedate(list[index]->filedata.file_date),
  575.                 filetime(list[index]->filedata.file_time));
  576.             printf("(%ld characters)\r\n",(long)list[index]->filedata.file_size);
  577.             fileterm(path,opts);
  578.             cr();
  579.             break;
  580.         case 'S':
  581.             sprintf(workstr,"%d by %s on %s is %ld characters:\r\n",
  582.                 list[index]->value,fname,
  583.                 filedate(list[index]->filedata.file_date),
  584.                 (long)list[index]->filedata.file_size);
  585.             mputs(workstr);
  586.             gnl_flag = TRUE;
  587.             for (i=0;i<MSGHDRSIZ && gnl_flag;++i)
  588.                 if (gnl_flag=(fgets(workstr,LINESIZE,path)!=NULL)) 
  589.                     mputs(workstr);
  590.             cr();
  591.             break;
  592.         }     /* End Switch */
  593.     if (path!=NULL) fclose(path);
  594.     }    /* End Else (no error opening file) */
  595. }
  596.  /* End Read or Scan */
  597.  
  598. static del_msg(fname,index)
  599. char fname[];
  600. int index;
  601. {
  602. if (strcmp(home_dir,uppercase(fname)) &&  /*  Not creator of MSG, AND */
  603.         !syswrite) { /* no system write priveledges */
  604.     printf("Only the creator of the message, user %s, or\r\n",fname);
  605.     printf("the system operator may delete msg %d.\r\n",list[index]->value);
  606.     return;
  607.     }
  608. else if (0 & (int)printf("Delete msg %d ? ",
  609.         list[index]->value) ||
  610.     !user_is_sure()) ;
  611. else if (unlink(list[index]->filedata.filename_ext)) {
  612.     printf("Error during delete of msg %d.\r\n",list[index]->value);
  613.     }
  614. else {
  615.     printf("Message %d deleted.\r\n",list[index]->value);
  616.     list[index]->filedata.filename_ext[0]='*'; /* Zap */
  617.     }
  618. }
  619.  
  620.  
  621. /* SMFILE: Send MAIL file */
  622. smfile(c,args,opts)
  623. char c, *args, *opts;
  624. {
  625. char boardname[11], filename[17], alt_user[11], mailfile[17];
  626. char b, *ftype, *type, *delete, *t1, *t2, *t3, *t4;
  627. char comments[LINESIZE+2];
  628. int gnl_flag, quiet, dlf, ndlf, posflg;
  629. FILE *fp;
  630.  
  631. if (!has_auth("R",cur_dir,cur_root)) {
  632.     not_auth('R',cur_dir,cur_root);
  633.     return;
  634.     }
  635.  
  636. t4 = stpblk(threeparse(args,&t1,&t2,&t3));
  637.  
  638. quiet = find_option(opts,'q');
  639. if (ndlf=find_option(opts,'k')) dlf = FALSE;    /* Only one: Keep, or Delete */
  640. else dlf=find_option(opts,'d');
  641. posflg = (find_option(opts,'!') && *t3);
  642.  
  643. if (!*args && !quiet && beginner) disp_msg(20);
  644.  
  645. if (!*t1) {
  646.     disp_reply(file_prompt(beginner,"send"),filename,14);
  647.     if (filename[0]=='\0') return(nothing_done());
  648.     }
  649. else stptok(t1,filename,sizeof(filename),"");
  650. if (check_fn(filename,TRUE)) return;
  651. if (check_rsvf(filename,TRUE)) return;    /* Can't use reserved filename */
  652. if ((fp=fopen(filename,"r"))==NULL) return(not_open());
  653. else {                            /* 1 */
  654.       fclose(fp);
  655.     gnl_flag = FALSE;
  656.     uppercase(filename);
  657. send_file:
  658.     if (!*t2) {
  659.         printf("Send message file: %s\r\n",filename);
  660.         if (beginner && !quiet) {
  661.               printf("If you want to use the public message board, type '%s'.\r\n",DEFLT_MSB);
  662.               printf("Enter username or message board name: ");
  663.               }
  664.         else printf("Boardname or user id: ");
  665.         disp_reply("",boardname,9);
  666.         }
  667.     else stptok(t2,boardname,sizeof(boardname),"");
  668.  
  669.     uppercase(boardname);
  670.     strcpy(alt_user,boardname);
  671.     if (boardname[0]) {
  672.         if (!sysdir(boardname,MESSAGES)) 
  673.             movetoboard(boardname,filename,cur_dir);
  674.         else if (sysdir(boardname,user_root)) 
  675.             printf("No user directory '%s' found.\r\n",boardname);
  676.         else if (sysdir("",MAILBOX)) {
  677.             printf("Sorry, mail system inoperable.\r\n");
  678.             printf("System mail directory not found.\r\n");
  679.             }
  680.      /*3*/    else {
  681.              stccpy(mailfile,alt_user,sizeof(mailfile));
  682.             strcat(mailfile,MAIL_EXT);
  683.             if ((fp=fopen(mailfile,"a"))==NULL)
  684.                 printf("Error opening user SYSMAIL file.\r\n");
  685.         /*4*/    else {
  686.                 if (!*t3) {
  687.                         printf("Enter 'M' for MAIL, or 'S' for file transfer: ");
  688.                     b = *ltrim(lineinput(2));
  689.                     }
  690.                 else b = *t3;
  691.                 if (toupper(b)=='S') {
  692.                     ftype = "File";
  693.                     type = "SEND";
  694.                     if (!*t4) disp_reply("Enter optional comment line:\r\n",comments,LINESIZE);
  695.                     else stptok(t4,comments,sizeof(comments),"");
  696.                     }
  697.                 else {
  698.                     comments[0] = '\0';
  699.                     type = "MAIL";
  700.                     ftype = "Mail";
  701.                     }
  702.                 if (!(dlf||ndlf)) {
  703.                     printf("File to be deleted when read (Y/N)? ");
  704.                     b = *ltrim(lineinput(2));
  705.                     }
  706.                 else b = dlf?'Y':'N';    /* 'Y' if delete flag */
  707.                 b = toupper(b);
  708.                 if (b=='Y') delete = "DELETE";
  709.                 else delete = "KEEP";    
  710.                 if (posflg) {
  711.                     printf("%s file: %s to %s%s; CORRECT ? ",type,filename,
  712.                         alt_user,b=='Y'?" and DELETE when read":"");
  713.                     b = *ltrim(lineinput(4));
  714.                     }
  715.                 else b = 'Y';
  716.                 if (toupper(b)!='Y') {
  717.                     fclose(fp);
  718.                     goto send_file;
  719.                     }
  720.                 sprintf(file_buff,"%s,%s,%s,%s,%s,%s,%s,%s\r\n",home_dir,filename,cur_dir,cur_root,delete,type,timedate(),comments);
  721.                 fputs(file_buff,fp);
  722.                 fclose(fp);
  723.                 printf("%s (%s) posted for '%s'.\r\n",ftype,filename,alt_user);
  724.                 if (!strcmp(delete,"DELETE")) printf("File will be deleted when read.\r\n");
  725.                 gnl_flag = TRUE;
  726.                 if (!*t2) goto send_file;
  727.                 } /* END ELSE 4 */
  728.             }  /* END ELSE 3 */
  729.         } /* END IF 2 */
  730.     if (gnl_flag) {
  731.         if (beginner && !quiet) {
  732.             printf("File sent.  You will be informed when it has been read.\r\n");
  733.             printf("Remember: the file you just queued, called '%s'\r\n",filename);
  734.             mputs("must remain in your directory until read by whoever you sent it\r\n");
  735.             mputs("to.  If you specified DELETE, it will be removed after being read.\r\n");
  736.             mputs("automatically by the system.\r\n");
  737.             }
  738.         }
  739.     } /* END ELSE 1 */
  740. }
  741.  
  742.  
  743. static msgaccinst(c,index)
  744. char c;
  745. int index;
  746. {
  747. char token[LINESIZE+2];
  748. ctlsctlk();
  749. cr();
  750. if (c=='R' || c=='r') mputs("Control-O will skip rest of message\r\n");
  751. sprintf(token,"%s mode: current msg# = %d\r\n",smsg_fnc(c),list[index]->value);
  752. mputs(token);
  753. mputs("CONTINUOUS: Enter 'F' for forward or 'B' for backward\r\n");
  754. mputs("INDIVIDUAL: Enter 'Y' for current msg, or enter msg#, or msg#'s\r\n");
  755. mputs("            (append '+' or '-' for continous)\r\n");
  756. }
  757. 
  758. 
  759.