home *** CD-ROM | disk | FTP | other *** search
/ Power Programming / powerprogramming1994.iso / progtool / c / crcbbs.arc / CRCPC0A.C < prev    next >
Text File  |  1985-10-22  |  13KB  |  513 lines
  1. #include "crcpchdr.h"
  2.  
  3. char *incptr(ptr)   /* Increment pointer only if not pointing at NULL char */
  4. char *ptr;
  5. {
  6. return ((*ptr)?stpblk(++ptr):ptr);
  7. }
  8.  
  9. int notnull(str)
  10. char *str;
  11. {
  12. for (;*str;str++) if (*str>' ') return 1;
  13. return 0;    /* All spaces or control codes in [ASCII] string */
  14. }
  15.  
  16. static char get_cmd(args)
  17. char *args;
  18. {
  19. struct cmd_list *search;
  20. char word[20];
  21.  
  22. stptok(args,word,sizeof(word)," ");
  23. uppercase(word);
  24. for (search=commands;search!=NULL;search=search->next) {
  25.     if (abbrev(search->name,word,search->abrl)) {
  26.         if (search->class<=userclass) return(search->cmd_id);
  27.         }
  28.     }
  29. return('\0');    /* didnt find it */
  30. }
  31.  
  32.  
  33. init_vars()
  34. {
  35. tflag = deftflag;
  36. termtype = deftermtype;
  37. utwidth = defutwidth;
  38. utlength = defutlength;
  39. utcls[0] = '\0';
  40. maxconnect = defmaxconnect;    /* Allow user on at max this many min.s */
  41. nousrto = FALSE;        /* Also initialized by 'read_userfile()'*/
  42. nousrfort = FALSE;        /*  "        "    "    "    */
  43. noforcenow = TRUE;        /* */
  44. beingforced = FALSE;        /* But not doing it yet */
  45. beginner = defbeginner;
  46. termwidth = deftermwidth;
  47. duplex = defduplex;
  48. }
  49.  
  50. char menu(retopts,retquiet)
  51. char **retopts;
  52. int *retquiet;
  53. {
  54. char c,d;
  55. char filename[15];
  56. char destfile[15];
  57. char *type;
  58. char *ftype;
  59. char *delete;
  60. int gnl_flag, quiet;
  61. static char inpbuff[LINESIZE+2];
  62. static char options[20];
  63. char *args, *getenv();
  64.  
  65. if (!beginner) goto skipcrap;
  66. drawit:
  67. cls();
  68. output = TRUE;
  69. printf("\r\n%s %s - User: %s - %s %s\r\n\r\n",SYSNAME,SYSVER,user_id,date(),time());
  70. help(MENUFILE,"t");
  71. cr();
  72.  
  73. skipcrap:
  74. gnl_flag = FALSE;
  75. forever {
  76.     output = TRUE ;
  77.     *retquiet = FALSE;
  78.     *retopts = "";
  79.     if (beingforced) {
  80.         beingforced = FALSE;
  81.         return('Y');
  82.         }
  83.     prompt();
  84.     args = disp_reply("",inpbuff,LINESIZE);
  85.     if (!dsr()) return('Q');
  86.     uppercase(args);        /* UPPERCASE ALL ARGUMENTS */
  87.     c = get_cmd(args);
  88.     args = strip_options(skptok(args),options);
  89.     quiet = find_option(options,'q');
  90.     *retquiet = quiet;        /* Pass back to caller if 'Q' cmmd */
  91.     *retopts = options;        /* " */
  92.     switch(c) { /* SWITCH */
  93.         case '?': goto drawit;
  94.     break;    case '~': dossys(getenv(UTIL_PROG),FALSE);
  95.     break;    case '+': dossys(skptok(inpbuff),TRUE);
  96.     break;    case '=': dossys(skptok(inpbuff),FALSE);
  97.     break;    case '_': runfile(skptok(inpbuff),TRUE);
  98.     break;    case '-': runfile(skptok(inpbuff),FALSE);
  99.     break;    case '/': user_set(c,args,options);
  100.     break;    case '#': mk_dir(c,args,options);
  101.     break;    case '%': rm_dir(c,args,options);
  102.     break;    case '@': xfer_file(c,args,options);
  103.     break;    case '$': any_news(c,args,options);
  104.     break;    case '!': see_dtables(c,args,options);
  105.     break;    case '*': do_fort(c,args,options);
  106.     break;    case '"': dup_file(c,args,options);
  107.     break;    case 'A': ask_sysop(c,args,options);
  108.     break;    case 'B': buzz_sysop(c,args,options);
  109.     break;    case 'C': create_file(c,args,options);
  110.     break;    case 'D': disp_dir(c,args,options);
  111.     break;    case 'E': erase_file(c,args,options);
  112.     break;    case 'F': fork_board(c,args,options);
  113.     break;    case 'G': go_dir(c,args,options);
  114.     break;    case 'H': yell_help(c,args,options);
  115.     break;    case 'I': help(SYSINFO,options);
  116.     break;    case 'J': jump_dir(c,args,options);
  117.     break;    case 'K': kill_board(c,args,options);
  118.     break;    case 'L': list_file(c,args,options);
  119.     break;    case 'M': msg_sys(c,args,options);
  120.     break;    case 'N': change_password(c,args,options);
  121.     break;    case 'O': other_systems(c,args,options);
  122.     break;    case 'P': mail(c,args,options);
  123.     break;    case 'Q':
  124.             if (find_option(options,'!')) c = 'Y';
  125.             else if (!(c=args[0])) {
  126.                 if (!quiet && beginner)
  127.                     printf("You are about to leave this system.\r\n");
  128.                 c = *disp_reply("Are you sure ? ",filename,4);
  129.                 }
  130.             c = toupper(c);
  131.             if (stpchr("YQX",c)==NULL) {
  132.                 nothing_done();
  133.                 break;
  134.                 }
  135.             if (c == 'Y') return c;
  136.             else if (c == 'Q') return c;
  137.             else if (c == 'X') {
  138.                 if (!strcmp(input_pw(9),exit_pw)) return c;
  139.                 }
  140.     break;    case 'R': rename_file(c,args,options);
  141.     break;    case 'S': smfile(c,args,options);
  142.     break;    case 'T': type_file(c,args,options);
  143.     break;    case 'U': user_data(c,args,options);
  144.     break;    case 'V': scan_events(c,args,options);
  145.     break;    case 'W': who_is(c,args,options);
  146.     break;    case 'X': beginner = !beginner;    expertstatus();
  147.     break;    case 'Y': systat(c,args,options);
  148.     break;    case 'Z': ask_sysop(c,args,"qf");
  149.     break;    default:  mputs("Type '?' for menu, type 'H' for help\r\n");
  150.         } /* END SWITCH */
  151.     sysdir(cur_dir,cur_root);    /* Make sure on current directory */
  152.     } /* FOR EVER */
  153. }
  154.  /* END MENU */
  155.  
  156. yell_help(c,args,opts)
  157. char c;
  158. char *args;
  159. char *opts;
  160. {
  161. int rc;
  162. strcat(opts,"u");        /* UPPERCASE; do not respect case for compare */
  163. rc = helplib(args,opts);
  164. if (rc==0) {
  165.     if (!*args) printf("Enter \"HELP name\" using name from above list\r\n");
  166.     }
  167. else if (rc==-1) printf("Nothing found.\r\n");
  168. else if (rc==1000) printf("* abort *\r\n");
  169. else printf("Help error: %d.\r\n",rc);
  170. }
  171.  
  172. char *prompt_str(level)
  173. int level;
  174. {
  175. if (level) return("Enter command or ? for menu");
  176.         else return(cur_dir);
  177. }
  178.  
  179. /* NOTE: If DEFLT true, then NULL command defaults to loading DOS */
  180. static int dossys(str,deflt)
  181. char *str;
  182. int deflt;
  183. {
  184. char *getenv();
  185. int rc;
  186. char doscmd[LINESIZE];
  187.  
  188. if (str==NULL) return(nothing_done());
  189. if (!*(str=stpblk(str))) {
  190.     if (!deflt) return(nothing_done());
  191.     if ((str=getenv(COMSPEC))==NULL) str = DEFLT_SYSCMD;
  192.     disp_msg(50);        /* Print default CMD instructions */
  193.     }
  194. stccpy(doscmd,str,sizeof(doscmd));  /* In case DOS plays with this */
  195. rc = system(doscmd);
  196. if (rc) printf("R(%d);\n",rc);
  197. return(rc);
  198. }
  199.  
  200. static int runfile(str,deflt)
  201. char *str;
  202. {
  203. char *offense;
  204.  
  205. if (*str && (offense=stpbrk(str,INVDOSCMDCHR))!=NULL) 
  206.     return(bad_fn(*offense));
  207. return(dossys(str,deflt));
  208. }
  209.  
  210. /* CHAT is called from bottom level routines MGETS and MPUTS */
  211. chat()
  212. {
  213. char line_buff[STR_SIZE+2];
  214.  
  215. cls();
  216. printf("\r\n\nChat mode - Control-Z gets out\r\n\n");
  217. line_buff[0]=STR_SIZE+1;
  218. do {
  219.     cgets(line_buff);
  220.     printf("\n");
  221.     } while(stpchr(&line_buff[2],CTLZ)==NULL);
  222. printf("\r\n\nReturning to previous task: \r\n\n");
  223. }
  224.  
  225.  
  226. eraselog() { if (!sysdir("",MAILBOX)) unlink(EVENT_LOG); }
  227.  
  228.  
  229. openlog()
  230. {
  231. if (nolog) event_fp=NULL;
  232. else {
  233.     if (sysdir("",MAILBOX)) event_fp=NULL;
  234.     else event_fp=fopen(EVENT_LOG,"a");
  235.     if (event_fp==NULL) printf("NOTE: Event log could not be opened.\r\n");
  236.     }
  237. }
  238.  
  239.  
  240. closelog() 
  241. { 
  242. if (event_fp!=NULL) {
  243.     sysdir("",MAILBOX);        /* DO WE NEED TO DO THIS ? */
  244.     fclose(event_fp);
  245.     event_fp = NULL;
  246.     }
  247. }
  248.  
  249.  
  250. logevent(event) 
  251. char event[]; 
  252. { 
  253. char timestr[32];
  254. strcpy(timestr,timedate());
  255. strcat(timestr," ");
  256. if (event_fp==NULL) return;
  257. writeln2(event_fp,timestr,event); 
  258. }
  259.  
  260.  
  261. /* These routines should later be removed to lower levels, such as -MD1 or MD2.
  262.    (MAYBE EVEN -BOT) 
  263. */
  264.  
  265. char *timedate()
  266. {
  267. static char timebuff[20];
  268. int hh,mm,ss,ms;
  269. int mo,dy,yr;
  270. sysdate(&mo,&dy,&yr);
  271. systime(&hh,&mm,&ss,&ms);
  272. sprintf(timebuff,"%02d/%02d %02d:%02d",mo,dy,hh,mm);
  273. return(timebuff);
  274. }
  275.  
  276.  
  277.  
  278. char *file_prompt(level,function)
  279. int level;
  280. char function[];
  281. {
  282. static char rb[LINESIZE+2];
  283. if (level) {
  284.     sprintf(rb,"Enter name of file to %s: ",function);
  285.     return(rb);
  286.     }
  287. else return("File? ");
  288. }
  289.  
  290.  
  291. int test_password()
  292. {
  293. char *string;
  294.  
  295. if (syspw[0]=='\0') return(TRUE);        /* No password - let him on */
  296. else {
  297.     printf("pw: ");
  298.     string = input_pw(9);
  299.     return(!strcmp(string,syspw));
  300.     }
  301. }
  302.  
  303.     
  304. int finput(filename,opts)
  305. char filename[];
  306. char *opts;
  307. {
  308. FILE *fp;
  309. char c;
  310. char line[STR_SIZE+4];
  311. int eof, linect, rc;
  312. int quiet;
  313.  
  314. quiet = find_option(opts,'q');
  315. if (*filename == '\0') return(nothing_done()&0+1);
  316. else if ((fp=fopen(filename,"r")) != NULL) {
  317.     fclose(fp);
  318.     if (find_option(opts,'a')) c = 'Y';
  319.     else {
  320.         printf("File already exists.\r\nWant to add lines to it ? ");
  321.         c = *ltrim(lineinput(2));
  322.         }
  323.     if (toupper(c)!='Y') {
  324.         printf("Use the ERASE command first.\r\n");
  325.         return(nothing_done()&0+1);
  326.         }
  327.     }
  328. if ((fp=fopen(filename,"a")) == NULL) {
  329.     not_open();
  330.     return(2);
  331.     }
  332. else {
  333.     if (!quiet) mputs("Enter input lines below, terminate with CTL-Z followed by <CR>.\r\n");
  334.     linect = 0;
  335.     rc = 0;
  336.     noforcenow = TRUE;
  337.     do {
  338.         strcpy(line,lineinput(STR_SIZE));
  339.         if (!dsr()) break;
  340.         eof = (stpchr(line,CTLZ)!=NULL);
  341.         del_crlf(line);
  342.         if (!eof) strcat(line,"\r\n");    /* Add text line end markers */
  343.         if (fputs(line,fp)==EOF) {
  344.              printf("DISK FULL or other error writing output file.\r\n");
  345.             rc = 3;
  346.             break;
  347.             }
  348.         else linect++;
  349.         } while (!eof);
  350.     noforcenow = FALSE;
  351.     if (fclose(fp)) {
  352.         printf("Error while closing file.\r\n");
  353.         return(4);
  354.         }
  355.     if (!quiet) printf("\r\n%d lines written to file '%s'\r\n",linect,filename);    
  356.     return(rc);
  357.     }
  358. }
  359.  
  360.  
  361. /* Parses normal "MM/DD/YY" form date into *PMO, *PDY, *PYR */
  362. extr_date(str,pmo,pdy,pyr)
  363. char *str;
  364. int *pmo, *pdy, *pyr;
  365. {
  366. char cmo[4], cdy[4], cyr[4];
  367.  
  368. *cmo = *cdy = *cyr = '\0';
  369. if (str) str = stptok(stpblk(str),cmo,sizeof(cmo),"/. ");
  370. if (str) str = stptok(++str,cdy,sizeof(cdy),"/. ");
  371. if (str) str = stptok(++str,cyr,sizeof(cyr),"/. ");
  372. *pmo = stoi(cmo);
  373. *pdy = stoi(cdy);
  374. *pyr = stoi(cyr);
  375. }
  376.  
  377.  
  378. /* CREATE_LIST:   We have already set up the DTA and issued a successsful
  379.           FIND_FIRST call to it.  We start allocating lines to it. */
  380. create_list()
  381. {
  382.     int rc;
  383.     rc = 0;
  384.     while(!rc) {
  385.         if (rc = add_list(&ftab_ptr->filedata)) ;
  386.         else rc = mdos(NEXT_FILE);
  387.         }
  388. }
  389.  
  390. /*****************************************************************************
  391.  *    add_list:  Add an 'element' (filedate/attrib/time/name info) to next *
  392.  *         (list_idx+1) element in string array.                 *
  393.  *****************************************************************************/
  394. int add_list(elemt)
  395. struct fileinfo *elemt;
  396. {
  397. struct dir_entry *newptr;
  398.  
  399. /* Obtain a memory for this elemt in the string array */
  400. if ((newptr=(struct dir_entry *)getmem(sizeof(**list)))==NULL) {
  401.     warn_omem();
  402.     return(100);
  403.     }
  404. /* Error if cannot get memory, else move the elemt into its place */
  405. /* (move elemt into fileinfo structure (FILEDATA)) */
  406. else movmem((char *)elemt,(char *)&newptr->filedata,sizeof(*elemt));
  407.  
  408. /* Put it in the array as next element, using LIST_IDX as index */
  409. list[list_idx++] = newptr;
  410.  
  411. /* Initialize value field to numeric value of filetype */
  412. /* Read extension of file, taking numeric value from it */
  413. newptr->value = stoi(file_ext(newptr->filedata.filename_ext));
  414.  
  415. /* Good return - element added to list */
  416. return(0);
  417. }
  418.  
  419. /*****************************************************************************
  420.  *    drop_list:  de-allocate the entire string array (use RLSMEM)         *
  421.  *****************************************************************************/
  422. drop_list()
  423. {
  424.     while(list_idx--) {
  425.         if (rlsmem((char *)list[list_idx],sizeof(**list)))
  426.             printf("Error during RLSMEM\r\n");
  427.         }
  428. list_idx = 0;
  429. }
  430.  
  431. /*****************************************************************************
  432.  *  SORT_LIST:  Sort the string array into ascending order, by VALUE.        *
  433.  *****************************************************************************/ 
  434. /* We have array in memory of pointers to structure type DIR_elemt.
  435.    we must sort this array according to ascending values found
  436.    in the 'value' variable in each structure. 
  437.    Note that since the data will be partially sorted, we will use the
  438.    bubble sort to take advantage of the partial sorted order.
  439.    (besides, its the only one i know by heart)    */
  440.  
  441. sort_list(list,n)
  442. struct dir_entry *list[];
  443. int n;
  444. {
  445.     int j;
  446.     int swapped;
  447.     struct dir_entry *temp;
  448.  
  449.     swapped = TRUE;
  450.     while(swapped) {
  451.         swapped = FALSE;
  452.         for (j=0;j<n-1;++j)
  453.             if (list[j]->value>list[j+1]->value) {
  454.                 swapped = TRUE;
  455.                 temp = list[j];
  456.                 list[j] = list[j+1];
  457.                 list[j+1] = temp;
  458.                 }
  459.         }
  460. }
  461.  
  462.  
  463. char *file_ext(fn)
  464. char *fn;
  465. {
  466. char *p;
  467.  
  468. if ((p=stpchr(fn,'.'))==NULL) return("");
  469. else return(p+1);
  470. }
  471.  
  472. char *get_name(dest,sourcefn)
  473. char *dest, *sourcefn;
  474. {
  475. char *p;
  476. int l;
  477.  
  478. if ((p=stpchr(sourcefn,'.'))==NULL) strcpy(dest,sourcefn);
  479. else {
  480.     l = p-sourcefn;                /* Get num chars in name */
  481.     if (l>0) {                /* I Don't trust myself */
  482.         movmem(sourcefn,dest,l);    /* Move in just filename */
  483.         }
  484.     else l = 0;
  485.     dest[l] = '\0';            /* Make printable string of it */
  486.     }
  487. return(dest);
  488. }
  489.  
  490. help(helpfile,opts)
  491. char helpfile[];
  492. char *opts;
  493. {
  494. char filename[DIRSIZE+17];
  495. prefix_dir(filename,helpfile,hpath);
  496. typefile(filename,opts);
  497. }
  498.  
  499. long cnct_seconds()
  500. {
  501. int hh,mm,ss,ms;
  502. systime(&hh,&mm,&ss,&ms);
  503. return(time_diff(login_hh,login_mm,login_ss,hh,mm,ss));
  504. }
  505.  
  506. print_cd()
  507. {
  508. printf("Current directory: %s\r\n",*cur_dir?cur_dir:"(node)");
  509. if (strcmp(user_root,cur_root) && *cur_root)
  510.     printf("Current root:      %s\r\n",cur_root);
  511. }
  512. 
  513.