home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / msdos / c / crcbbs.arc / CRCPC0B.C < prev    next >
Encoding:
C/C++ Source or Header  |  1985-10-22  |  14.3 KB  |  580 lines
  1. #include "crcpchdr.h"
  2.  
  3. /* SEP_DIR_FN:  Separate filename/pathname into DIRECTORY part, and file part */
  4. /*    SIZE OF OUTPUT BUFFERS "DIR" AND "FILE" ARE USERS RESPONSIBILTY */
  5. sep_dir_fn(curspec,dir,file)
  6. char *curspec, dir[], file[];
  7. {
  8. int i;
  9.  
  10. dir[0] = file[0] = '\0';
  11. i = strlen(curspec);
  12. if (i) {
  13.     while(curspec[--i]!=ESCSYM && curspec[i]!=DRVSYM && i!=0);
  14.                 /* COPY ENTIRE PATH, INCL ESCSYM */
  15.     if (i || curspec[i]==ESCSYM) stccpy(dir,curspec,++i+1); 
  16.     strcpy(file,curspec+i);    /* File name */
  17.     zaphesc(dir);        /* Now delete ESCSYM if possible */
  18.     }
  19. }
  20.  
  21. char *threeparse(inp,one,two,three)
  22. char *inp;
  23. char **one, **two, **three;
  24. {
  25. static char uno[LINESIZE], dos[LINESIZE], tres[LINESIZE];
  26. char *ptr;
  27. ptr = stptok(stpblk(inp),uno,LINESIZE," \r");
  28. ptr = stptok(stpblk(ptr),dos,LINESIZE," \r");
  29. ptr = stptok(stpblk(ptr),tres,LINESIZE," \r");
  30. *one = uno;
  31. *two = dos;
  32. *three = tres;
  33. return(ptr);
  34. }
  35.  
  36. int sysmkdir(dirname,rootname)
  37. char dirname[], rootname[];
  38. { return(dos_dir_int(dirname,DOS_MKDIR,rootname)); }
  39.  
  40.  
  41. int sysrmdir(dirname,rootname)
  42. char dirname[], rootname[];
  43. {
  44. return(dos_dir_int(dirname,DOS_RMDIR,rootname));
  45. }
  46.  
  47.  
  48. /* 
  49.     F_U_MSG(BOARDNAME):  Return pointer to board history record for boardname.
  50.                                           */
  51. struct lmsg *f_u_msg(board)
  52. char board[];
  53. {
  54. struct lmsg *lmsg_ptr;
  55. for (lmsg_ptr=lmsg_start;lmsg_ptr!=NULL;lmsg_ptr=lmsg_ptr->next_lmsg)
  56.     if (!strcmp(lmsg_ptr->boardname,board)) return(lmsg_ptr);
  57. return(NULL);
  58. }
  59.  
  60. int l_u_msg(board)        /* RETURN LAST MSG READ BY USR LAST TIME */
  61. char board[];
  62. {
  63. struct lmsg *lup;
  64. if ((lup=f_u_msg(board))==NULL) return(0);  /* Havent been on this BRD before */
  65. else return(lup->lmr);                /* Return last message read */
  66. }
  67.  
  68. int l_b_msg(board)        /* RETURN LAST MSG ON BOARD LAST TIME */
  69. char board[];
  70. {
  71. struct lmsg *lup;
  72. if ((lup=f_u_msg(board))==NULL) return(0);  /* Havent been on this BRD before */
  73. else return(lup->lmb);                /* Return last message on BD */
  74. }
  75.  
  76. /* A_U_MSG(BOARDNAME):   Add (define or change) 'last msg read' counter for
  77.              boardname.    Returns NULL if GETMEM error.       */
  78. struct lmsg *a_u_msg(board,lmb,lmr,mo,dy,yr)
  79. char board[];
  80. int lmb,lmr;
  81. int mo,dy,yr;
  82. {
  83. struct lmsg *lmsg_ptr;
  84.                 /* Do we already have it in our list ? */
  85. if ((lmsg_ptr=f_u_msg(board))!=NULL) goto foundit;
  86.                 /* No, so we must allocate memory & build it */
  87. if ((lmsg_ptr=(struct lmsg *)getmem(sizeof(*lmsg_ptr)))==NULL) warn_omem();
  88. else {
  89.     lmsg_ptr->next_lmsg = lmsg_start;    /* We point to old start */
  90.     lmsg_start = lmsg_ptr;            /* We become the first */
  91.     strcpy(lmsg_ptr->boardname,board);
  92. foundit:lmsg_ptr->lmb = lmb;
  93.     lmsg_ptr->lmr = lmr;
  94.     lmsg_ptr->mo  = mo;
  95.     lmsg_ptr->dy  = dy;
  96.     lmsg_ptr->yr  = yr>99?yr-BASEYEAR:yr;
  97.     }
  98. return(lmsg_ptr);
  99. }
  100.  
  101. int dir(fn,type) 
  102. char *fn ;               
  103. unsigned type;
  104. {
  105.     int i, rc, orc;
  106.     char dirout[LINESIZE];
  107.  
  108.     orc = setup_dir(fn,type) ;
  109.     rc = orc ;
  110.     while (rc==0) {
  111.         if (type==DIR_TYP) {
  112.             if (ftab_ptr->filedata.attribute==DIR_TYP) {
  113.                 if (!strcmp(ftab_ptr->filedata.filename_ext,".") ||
  114.                     !strcmp(ftab_ptr->filedata.filename_ext,"..") ) ;
  115.                 else {
  116.                     sprintf(dirout,"%-9s %s\r\n",
  117.                               ftab_ptr->filedata.filename_ext,
  118.                         filedate(ftab_ptr->filedata.file_date));
  119.                     mputs(dirout);
  120.                     }
  121.                 }
  122.             rc = mdos(NEXT_FILE);
  123.             }
  124.         else {
  125.             for (i=0;(i<2)&&(!rc);++i) {
  126.                 sprintf(dirout,"%14.13s %7.2fK",
  127.                     ftab_ptr->filedata.filename_ext,
  128.                        (float)    (ftab_ptr->filedata.file_size/1024.0)+0.005);
  129.                 mputs(dirout);
  130.                 mputs("  ");
  131.                 rc = mdos(NEXT_FILE);
  132.                 }        
  133.             cr();
  134.             }
  135.         }    /* End While rc==0 */
  136. return(orc);
  137. }
  138.     /* End DIR */
  139.  
  140. int setup_dir(fn,type)
  141. char *fn;
  142. unsigned type;
  143. {
  144.     int i, rc;
  145.  
  146.     if (*fn == '\0') strcpy(fn,"*.*"); /* NOTE: LEN(fn[]) >= 4 chars! */
  147.     bdos(SET_DTA,disk_buffer);    /* Set up our own DTA */
  148.                     /* And get it from system */
  149.     ftab_ptr = (struct fn_struc *) getdta();
  150.     rc = mdos(FIND_FILE,NA,NA,type,fn);
  151.     switch(rc) {        /* Look for ALL files, add them to list */
  152.         case 2: printf("File not found.\r\n");
  153.                 break;
  154.         case 18: printf("Nothing found\r\n");
  155.             break;
  156.         } /* endswitch */
  157. return(rc);
  158. }
  159.  
  160. char *filetime(codetime)
  161. unsigned codetime;
  162. {
  163. static char ftime[6];
  164. sprintf(ftime,"%2d:%02d",(codetime&0xF800)>>11,
  165.               (codetime&0x07E0)>>5);
  166. return(ftime);
  167. }
  168.  
  169. char *filedate(codedate)
  170. unsigned codedate;
  171. {
  172. static char fdate[11];    
  173.  
  174. sprintf(fdate,"%02d/%02d/%02d",
  175.     (codedate&0x01E0)>>5,
  176.     (codedate&0x001F),
  177.     ((codedate&0xFE00)>>9)+80);
  178. return(fdate);
  179. }
  180.  
  181. int baddir(dirname)
  182. char dirname[];
  183. {
  184. printf("INVALID OR NON EXISTING DIRECTORY: '%s'.\r\n",dirname);
  185. return(3);
  186. }
  187.  
  188. char *on_off(bool)
  189. int bool;
  190. {
  191. if (bool) return("on");
  192. else return("off");
  193. }
  194.  
  195. not_open() { printf("Could not open file\r\n"); }
  196.  
  197. int dsr() { return(rdsr() || sys_test); }
  198.  
  199. del_crlf(s)
  200. char *s;
  201. {
  202. while(*s && !stpchr("\r\n",*s) && *s!=CTLZ) s++;
  203. *s = '\0';
  204. }
  205.  
  206. writeln2(iop,s1,s2)
  207. FILE *iop;
  208. char *s1, *s2;
  209. {
  210. fputs(s1,iop);
  211. fputs(s2,iop);
  212. fputs("\r\n",iop);
  213. }
  214.  
  215. not_auth(c,dir,root)
  216. char c, dir[], root[];
  217. {
  218. char outs[ROOTSIZE+DIRSIZE];
  219. printf("Access denied [%c;%s]\r\n",c,prefix_dir(outs,dir,root));
  220. }
  221.  
  222. invpath(rc,offensive_path)
  223. int rc;
  224. char *offensive_path;
  225. {
  226. if (beginner) printf("Invalid pathname: %s\r\n",offensive_path);
  227. else printf("Bad pathname\r\n");
  228. }
  229.  
  230. /* HAS_AUTH:  Changes directory to test directory and diagnoses 'ACCESS.USR'
  231.           if necessary to obtain answer.
  232.  
  233.     06/06/84: Patch to make any PUBLIC directory OK for READ access.
  234.  
  235.     1)  All users have R/W access to all their own directories except PUBLIC
  236.         (who has R/W to TOP level, and R/O to other levels)
  237.     2)  All users have R/O access to any directory on the MESSAGES root    
  238.     3)  Priveledged users given global access according to: SYSREAD/SYSWRITE
  239.     4)  All other requests given to routine: 'CHECK_ACC' for final dispostn.
  240.         
  241.     07/22/84:  I've decided that this is a kludgey routine:
  242.         IT SHOULD BE RE-WRITTEN.
  243.  
  244. */
  245. has_auth(s,tdir,troot)
  246. char *s, tdir[], troot[];
  247. {
  248. char *ept;
  249. char dir[DIRSIZE];        /* All these buffers are required because of */
  250. char root[ROOTSIZE];        /* previous design 'problems'.               */
  251. int onsys, home, msgsys, subdir;
  252. int ans;
  253. char test[DIRSIZE+ROOTSIZE];    
  254. static char ctest[DIRSIZE+ROOTSIZE];
  255. static char creq[10];
  256. static int lastans;
  257.  
  258. uppercase(s);
  259. if (!strcmp(prefix_dir(test,tdir,troot),ctest) && !strcmp(creq,s)) 
  260.     return(lastans);
  261. stccpy(creq,s,sizeof(creq));
  262. strcpy(ctest,test);
  263.  
  264. stccpy(dir,tdir,sizeof(dir));
  265. stccpy(root,troot,sizeof(root));
  266. uppercase(dir);
  267. uppercase(root);
  268. onsys = strcmp(root,user_root);
  269. msgsys = !strcmp(root,MESSAGES);
  270. if (*dir==ESCSYM) strcpy(dir,dir+1);
  271. if ((ept=stpchr(dir,ESCSYM))!=NULL) {
  272.     *ept = '\0';
  273.     subdir = TRUE;
  274.     }
  275. else subdir = FALSE;
  276. home = !strcmp(dir,home_dir) && !onsys;    /* Home iff first level dir=HOME_DIR */
  277. if (home && strcmp(home_dir,DEFLT_DIR)) ans = TRUE; /* Access to own dirs except PUBLIC */
  278. else switch(*s) {
  279.     case 'R': 
  280.         if (msgsys) ans = TRUE;        /* Can ALWAYS read MESSAGES */
  281.         else if (onsys) ans = sysread;    /* Other system dirs: req. SYSREAD priv. */
  282.         else if (userread) ans = TRUE;    /* Not SYS, if global user read, OK too */
  283.         else if (!strcmp(dir,DEFLT_DIR)) ans = TRUE;  /* Always READ public */
  284.         else ans=check_acc(s,tdir,root);/* Otherwise go fetch ACCESS.USR    */
  285.         break;
  286.     case 'W': 
  287.         if (onsys) ans = syswrite;
  288.         else if (userwrite) ans = TRUE;
  289.         else if (home && !subdir) ans =TRUE;  /* PUBLIC can write to TOP LEVEL DIR */
  290.         else ans=check_acc(s,tdir,root);
  291.         break;
  292.     }
  293. return(lastans=ans);        /* ?? */
  294. }
  295.  
  296. /* Patch 02/02/84; Accepts username of '*' for global user specification */
  297. static int check_acc(s,dir,root)
  298. char *s, dir[], root[];
  299. {
  300. char save_dir[DIRSIZE], 
  301.     save_root[ROOTSIZE], 
  302.     *parseptr, 
  303.     token1[9], 
  304.     token2[5];
  305. int answer;
  306. FILE *fp;
  307.  
  308. strcpy(save_dir,cur_dir);        /* Save global current directory */
  309. strcpy(save_root,cur_root);        /* And root */
  310. sysdir(dir,root);            /* Go to requested spot */
  311. answer = FALSE;
  312. if ((fp=fopen(ACCESS_USR,"r"))!=NULL) {
  313.     while(fgets(file_buff,STR_SIZE,fp)!=NULL) {
  314.         del_crlf(file_buff);
  315.         if (file_buff[0]) {
  316.             uppercase(file_buff);
  317.             parseptr = stpblk(stptok(stpblk(file_buff),token1,9," \r"));
  318.             parseptr = stptok(parseptr,token2,5," \r");
  319.             if (token1[0]==CTLZ) ;    /* Skip possible last rec from editor */
  320.             else if (!strcmp(token1,user_id) || !strcmp(token1,"*")) {
  321.                 answer = (answer||(stpchr(token2,*s)!=NULL));
  322.                 }
  323.             }
  324.         }
  325.     fclose(fp);
  326.     }
  327. sysdir(save_dir,save_root);        /* Restore our old file system */
  328. return(answer);
  329. }
  330.  
  331. expertstatus()
  332. {
  333. printf("Expert mode is: %s\r\n",on_off(!beginner));
  334. }
  335.  
  336. int mxti(sstr,index)
  337. char *sstr;
  338. int index;
  339. {
  340. char *array[3];
  341. threeparse(sstr,&array[0],&array[1],&array[2]);
  342. return(stoi(array[--index]));
  343. }
  344.  
  345. cusfn() { mputs("Cannot use same filename\r\n"); }
  346.  
  347. prompt()
  348. {
  349. output = TRUE;
  350. if (beginner) {
  351.     mputs("----------\r\n");
  352.     mputs("Main Level\r\n");
  353.     mputs("----------\r\n");
  354.     cr();
  355.     }
  356. printf("%s> ",prompt_str(beginner));
  357. }
  358.  
  359. int scanstr(source,search,invl)
  360. char *source, search[];
  361. int invl;
  362. {
  363. int i, j, lsorc, lserc;
  364.  
  365. lsorc = strlen(source);
  366. lserc = strlen(search);
  367.  
  368. if (lserc==invl) for (i=0;i<lsorc-lserc+1;i+=lserc) {
  369.     for (j=0;j<lserc;j++) if (source[i+j]!=search[j]) break;
  370.     if (j==lserc) return i+1;    /* Match! - return index + 1 */
  371.     }
  372. return 0;
  373. }
  374.  
  375. static rsvf(fn) 
  376. char *fn;
  377. {
  378. printf("Reserved filename: `%s'\r\n",fn);
  379. }
  380.  
  381. int check_rf(fn,msg,bd,l)
  382. char *fn, *bd;
  383. int msg, l;
  384. {
  385. char *badchr;
  386. char filename[17];
  387.  
  388. stccpy(filename,ltrim(fn),sizeof(filename));
  389. uppercase(filename);
  390. if (badchr=stpbrk(filename,INVDOSFNCHR)) *badchr='\0';  /* Zap at first badchar */
  391. if (scanstr(bd,filename,l)) {
  392.     if (msg) rsvf(filename);
  393.     return TRUE;
  394.     }
  395. else return FALSE;
  396. }
  397.  
  398. int check_rsvf(fn,msg)
  399. char *fn;
  400. int msg;
  401. {
  402. if (check_rf(fn,FALSE,"CONAUXPRNNUL",3) || 
  403.     check_rf(fn,FALSE,"COM1COM2LPT1LPT2",4)) {
  404.     if (msg) rsvf(fn);
  405.     return TRUE;
  406.     }
  407. else return FALSE;
  408. }
  409.  
  410. int check_fn(fn,msg)
  411. char *fn;
  412. int msg;
  413. {
  414. char *badchr;
  415. if (badchr=stpbrk(fn,INVDOSFNCHR)) {
  416.     if (msg) bad_fn(*badchr);
  417.     return TRUE;
  418.     }
  419. else return FALSE;
  420. }
  421.  
  422. bad_dpn(c,s) 
  423. char c, *s; 
  424. { 
  425. if (beginner) printf("You can't use '%c' in a %sname\r\n",c,s); 
  426. else printf("'%c' ?!\r\n",c);
  427. }
  428.  
  429. bad_dn(c) char c; { bad_dpn(c,"directory "); }
  430.  
  431. bad_pn(c) char c; { bad_dpn(c,"path"); }
  432.  
  433. bad_fn(c) char c; { bad_dpn(c,"file"); }
  434.  
  435. /* FILECOPY:  Copy a file, possibly between directories, always on USER_ROOT
  436.     TEXT = TRUE if file is text file.
  437.     CREATE = TRUE if no append to be done.
  438.                                     */
  439. int filecopy(destdir,destfile,sourcedir,sourcefile,text,create)
  440. char destdir[], destfile[],sourcedir[], sourcefile[];
  441. int text, create;
  442. {
  443. char newdstd[DIRSIZE+ROOTSIZE+2], newsrcd[DIRSIZE+ROOTSIZE+2];
  444. prefix_dir(newdstd,destdir,user_root);
  445. prefix_dir(newsrcd,sourcedir,user_root);
  446. return(sysfcopy(newdstd,destfile,newsrcd,sourcefile,text,create));
  447. }
  448.  
  449. int sysfcopy(destdir,destfile,sourcedir,sourcefile,text,create)
  450. char sourcedir[], sourcefile[], destdir[], destfile[];
  451. int text, create;
  452. {
  453. int rc;
  454. char source[DIRSIZE+ROOTSIZE];
  455. char dest[DIRSIZE+ROOTSIZE];
  456.  
  457. rc = 100;    /* Guilty until innocent */
  458. if (check_rf(sourcefile,TRUE,"AUXCONNULPRN",3)) return(rc);
  459. if (check_rf(sourcefile,TRUE,"LPT1LPT2COM1COM2",4)) return(rc);
  460. if (check_rf(destfile,TRUE,"AUXCONPRN",3)) return(rc);
  461. if (check_rf(destfile,TRUE,"LPT1LPT2COM1COM2",4)) return(rc);
  462. prefix_dir(source,sourcefile,sourcedir);
  463. prefix_dir(dest,destfile,destdir);
  464. if (rc=doscopy(source,dest,!create,text)) {
  465.     if (rc==-1) printf("Disk full!\r\n");
  466.     else if (rc==2) printf("Could not read: %s\r\n",source);
  467.     else if (rc==3) printf("Could not open: %s\r\n",dest);
  468.     else printf("copy error: %d\r\n",rc);
  469.  
  470. #if DEBUG==TRUE
  471.     if (debug) printf("DOS rc=%d, %s -> %s\r\n",rc,source,dest);
  472. #endif
  473.  
  474.     }
  475. return(rc);                /* Return with status */
  476. }
  477.  
  478. #define        READ    0x8000
  479. #define        CREATE    0x8301
  480. #define        APPEND    0x8109
  481. #define     BLKSIZE    0x0200
  482.  
  483. int doscopy(from,to,append,text)
  484. char *from, *to;
  485. int append, text;
  486. {
  487. int rc, f1, f2, bytes, wmode, rmode;
  488. char buffer[BLKSIZE];
  489.  
  490. wmode = append?APPEND:CREATE;
  491. rmode = READ;
  492. if (text) { wmode &= 0x7FFF; rmode &= 0x7FFF; }
  493. rc = 0;
  494. if ((f1=open(from,rmode))==0) rc = 2;        /* Input file not found ? */
  495. else if ((f2=open(to,wmode))==0) rc = 3;    /* path not found ? */
  496. else {
  497.     do {
  498.         if ((bytes=read(f1,buffer,BLKSIZE))<0) rc = 2 ;    /* read error */
  499.         else if (write(f2,buffer,bytes)!=bytes) rc = -1;  /* DISK FULL */
  500.         } while (bytes==BLKSIZE && rc==0);
  501.     }
  502. if (f1) close(f1);
  503. if (f2) {
  504.     close(f2);
  505.     if (rc && !append) unlink(to);
  506.     }
  507. return rc;
  508. }
  509.  
  510. char *usname()
  511. {
  512. char *bp;
  513. static char usern[LINESIZE];    /* I WISH IT DIDNT HAVE TO BE THIS LONG! */
  514.                 /* --- or STATIC ! */
  515. if (!strcmp(home_dir,DEFLT_DIR)) return("");
  516. else if (*username=='\0') return(user_id);
  517. else {
  518.     strcpy(usern,username);
  519.     if ((bp=stpchr(usern,' '))!=NULL) *bp = '\0';
  520.     return(usern);
  521.     }
  522. }
  523.  
  524. inv_arg()
  525. {
  526. printf("Invalid argument(s)\r\n");
  527. }
  528.  
  529. /*  Create a human-readable (decimal) list of numbers, delimited by comma */
  530. char *dec_list(charlist,binlist,maxlen)
  531. char *charlist, *binlist;
  532. int maxlen;
  533. {
  534. int i, j;
  535. char number[15];
  536.  
  537. for (charlist[0]='\0',i=0,j=0;i<maxlen && binlist[j]!='\0';++j) {
  538.     sprintf(number,"%d",binlist[j]);
  539.     strcat(charlist,number);
  540.     i += strlen(number)+1;
  541.     if (i<maxlen && binlist[j+1]!='\0') strcat(charlist,",");
  542.     }
  543. return(charlist);
  544. }
  545.  
  546. /*  Create a computer-readable (binary) list of numbers, delimited by comma */
  547. /*  from human readable decimal number sequence in CHARLIST */
  548. /*  Returns NULL on error, or 'binlist', if no error */
  549. char *bin_list(binlist,charlist,maxlen)
  550. char *charlist, *binlist;
  551. int maxlen;
  552. {
  553. int i, j;
  554. char number[15];
  555. char *strptr;
  556.  
  557. i = 0;
  558. if (maxlen<2) return(NULL);
  559. if (!charlist[0]) binlist[0] = '\0';
  560. else {
  561.     strcat(charlist,",");
  562.     strptr = stptok(charlist,number,15," ,");
  563.     do {
  564.         if ((j=stoi(number))<1 || j>255) {
  565.             if (beginner) printf("'%s' is not a valid ASCII code.\r\n",number);
  566.             else printf("'%s' ?!\r\n",number);
  567.             return(NULL);
  568.             }
  569.         else {
  570.             binlist[i++] = j;
  571.             binlist[i] = '\0';
  572.             }
  573.         number[0] = '\0';
  574.         if (stpchr(" ,",*strptr)!=NULL) strptr=stptok(stpblk(strptr+1),number,15," ,");
  575.         } while(*number && i<maxlen);
  576.     }
  577. return(binlist);
  578. }
  579. 
  580.