![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / a / usr / bob / test / mwcbbs|
Return to main.c CVS log | Up to [MW Coherent from dump] / coherent / a / usr / bob / test / mwcbbs |
1.1 root 1: #include <stdio.h>
2: #include <curses.h>
3: #include "contents.h"
4:
5:
6:
7: main(argc, argv)
8: int argc;
9: char *argv[];
10:
11: {
12:
13: WINDOW *win1, *win2;
14: int x;
15: char dummy[50];
16:
17: printflag = 0;
18: strcpy(recdir,RECEIVER);
19: if(argc > 3)
20: {
21: printf("Too many arguments!\n");
22: exit(1);
23: }
24:
25: /* parse the command line argument for a 'p' or a 'P' so
26: * that we know to PRINT a file. If we hit a '?', then
27: * print a usage: message.
28: */
29:
30: bbsdatafile(); /* read the .mwcbbs data file, if it exists */
31:
32: if((argc==2)||(argc==3))
33: {
34: for(x=0;x<strlen(argv[1]);x++)
35: {
36:
37: /* test for v */ if( argv[1][x] == 'v' ){
38: printf("mwcbbs interface version %s\n",
39: VERSION);
40: exit(0);
41: }
42: /* test for pP */ if((argv[1][x] == 112) || (argv[1][x] == 80))
43: break;
44:
45: /* test for dD */ if((argv[1][x] == 100) || (argv[1][x] == 68))
46: {
47: strcpy(dummy,argv[2]);
48: if(argc < 3)
49: {
50: printf("No directory specified!\n");
51: exit(1);
52: }
53: if (strlen(dummy) < 2)
54: {
55: printf("Invalid destination specified!\n");
56: exit(1);
57: }
58: strcpy(recdir," ");
59: strcat(recdir,dummy);
60: break;
61: }
62:
63: if(argv[1][x] == '?')
64: {
65: printf("Usage:\tmwcbbs [options] directory\n");
66: printf("\tOptions:\n");
67: printf("\t -[Pp] print Contents files\n");
68: printf("\t -[Dd] specify destination directory\n");
69: printf("\t -[v] specify interface version\n");
70: printf("\t -[?] usage message\n");
71: exit(1);
72: }
73: }
74: }
75:
76: /* the following should only be executed if the above
77: * loop went all the way thru the argument passed, which means
78: * that we did not find a [pP].
79: */
80:
81: if ((argc==2) && (x==strlen(argv[1])))
82: {
83: printf("Unknown option %s\n",argv[1]);
84: exit(1);
85: }
86: else
87:
88: /* we found that there is one argument and that it is [pP],
89: * so set a printflag. We should only set this flag if argc = 2.
90: * The if statement ensures that printflag will only be set
91: * if there was one argument passed.
92: */
93: {
94: if(argc==2)
95: printflag = 1;
96: }
97:
98: initscr();
99: raw();
100: noecho();
101:
102: /* allocate memory for windows. print message on failure. */
103:
104: if((win1=newwin(20, 79, 0,0)) == NULL)
105: {
106: printf("\007Window Memroy allocation for win1 failed!\n");
107: exit(1);
108: }
109:
110: if((win2=newwin(20, 79, 0,0)) == NULL)
111: {
112: printf("\007Window Memroy allocation for win2 failed!\n");
113: exit(1);
114: }
115:
116: screen_num = 0;
117:
118:
119: /* now we get the user's choice of file to process */
120:
121: do {
122: getfilename();
123:
124:
125: /* if we're printing, call the print function. After
126: * completion, exit the program. We want to exit the
127: * because we don't want the user to automatically
128: * run the print function again and overwrite the
129: * data file written by the previous run-through.
130: */
131:
132:
133: /* added 11/21/91: If 'quit' was selected from the
134: * menu, we don't want to run the print option. Beta
135: * version 3 would allow the print routine to be entered
136: * and would later exit with a 'cannot find QUIT' message.
137: */
138:
139: if((printflag == 1) && (strcmp(workfile,"QUIT") != 0))
140: {
141: print(win2);
142: strcpy(workfile,"QUIT");
143: }
144:
145: /* if we did NOT select the mail option, then read the indicated
146: * Content file.
147: */
148:
149: if (strcmp(workfile,"QUIT")==0)
150: break;
151:
152: if (strstr(workfile,MAILFILE) == NULL)
153: x = rfile();
154: show_files(win1, win2, x);
155:
156: }
157: while( strcmp(workfile,FILE6) != 0);
158:
159: noraw();
160: endwin();
161:
162: }
163:
164:
165:
166:
167: /* show_files()
168: * This function will display the filenames read to a curses
169: * screen.
170: */
171:
172:
173: void show_files(win1, win2, EOF_FLAG)
174: WINDOW *win1, *win2;
175: int EOF_FLAG;
176:
177: {
178: char arrow;
179: int prevcol =1;
180: int prevrow =0; /* prevcol = column before arrow */
181: int newrow =0; /* prevrow = row before arrow */
182: int newcol =1; /* newrow = row after arrow */
183: int counter = 0; /* newcol = column after arrow */
184:
185:
186:
187:
188: /* if the mail option was selected, print the states to the window,
189: * else print the filenames from the read Contents file to the window.
190: */
191:
192: /* if we are in add/remove mode, then we want to print mail accounts
193: * by SITE to the workscreen, NOT the list of states.
194: */
195:
196: if ( (strstr(workfile,FILE4) != NULL) )
197: {
198: print_states(win1);
199: EOF_FLAG = -1;
200: }
201:
202: else
203: write_win(win1);
204:
205: menu();
206:
207:
208: /* highlite a filename. This is accomplished by going to a designated
209: * row and column, as determined by the row and counter nested loops.
210: * The innermost loop gets the character found, copies the retrieved
211: * character into a string and deletes the character from the screen.
212: * When the filename has been deleted from the screen, it is reprinted
213: * to the screen with highliting turned on. Padding for spaces must be
214: * accounted for since deleting chars shifts everything on the line one
215: * space to the left.
216: */
217:
218: /* print the first file in inverse video */
219:
220: lite (win1, prevrow, prevcol, 1,0);
221:
222: do
223: {
224: noecho();
225:
226: /* now we need to get a key (preferably an arrow) */
227:
228:
229:
230: arrow = getch(); /* This stupid code should allow to use arrows keys */
231: if (arrow == 27) /* that looks more frendly than hjkl. Vlad 8/15/91 */
232: {
233: getch();
234: arrow = getch(); /* When an arrow key is pressed, an escape */
235: if (arrow == 68) /* sequence is returned. The value '27' */
236: arrow = 'h'; /* begins the sequence and the relevant */
237: if (arrow == 67) /* values needed end the sequence. The */
238: arrow = 'l'; /* middle value is not needed, so it is */
239: if (arrow == 66) /* skipped over with a getch() statement */
240: arrow = 'j';
241: if (arrow == 65)
242: arrow = 'k';
243: }
244:
245:
246: /* each movement case in the following switch...case will test to see if the
247: * new position returns a space. If a space is returned, then we will hit
248: * an empty field, which we don't want to do. If we hit an empty space,
249: * then don't move the cursor.
250: */
251:
252: switch(arrow)
253: {
254: case 'h': /* move left */
255: newcol = prevcol - 15;
256: if (newcol < 1)
257: newcol = 61;
258: if (' ' == mvwinch(win1,newrow,newcol))
259: newcol = 1;
260: break;
261:
262:
263: case 'l': /* move right */
264: newcol = prevcol + 15;
265: if (newcol > 61)
266: newcol = 1;
267: if (' ' == mvwinch(win1,newrow,newcol))
268: newcol = 1;
269: break;
270:
271:
272: case 'j': /* move down */
273: newrow = prevrow + 1;
274: if (newrow == 20)
275: newrow = 0;
276: if (' ' == mvwinch(win1,newrow,newcol))
277: newrow = 0;
278: break;
279:
280:
281: case 'k': /* move up */
282: newrow = prevrow -1;
283: if (newrow == -1)
284: newrow = 19;
285: if (' ' == mvwinch(win1,newrow,newcol))
286: newrow = 0;
287: break;
288:
289:
290: case 'p':
291: screen_num --;
292: newrow = 0;
293: newcol = 1;
294: if (screen_num < 0)
295: screen_num = 0;
296: else
297: {
298: EOF_FLAG = rfile();
299: write_win(win1);
300: }
301: break;
302:
303:
304: case 'n':
305: newrow = 0;
306: newcol = 1;
307: if (EOF_FLAG == -1)
308: break;
309: else
310: {
311: screen_num ++;
312: EOF_FLAG = rfile();
313: write_win(win1);
314: }
315: break;
316:
317: /* when we 'quit', we need to make sure that the screen number
318: * is set to 0 so that when the next file is selected, we begin
319: * at the start of the file. If not, we run the risk of reading
320: * something and causing a dump, or worse, system corruption.
321: */
322:
323: case 'Q':
324: case 'q':
325: screen_num = 0;
326: break;
327:
328: case 13:
329: case 'S':
330: case 's':
331: wclear(win1);
332: wrefresh(win1);
333: wclear(win2);
334:
335: if((strstr(workfile,mapfile[0]) != NULL) || (strstr(workfile,mapfile[1])!= NULL) || (strstr(workfile,mapfile[2])!= NULL))
336: {
337: map_command(win2,prevrow,prevcol,screen_num);
338: wclear(win1);
339: rfile();
340: write_win(win1);
341: wrefresh(win1);
342: break;
343: }
344:
345: if( strstr(workfile,MAILFILE) != NULL)
346: {
347: print_mail_states(win2);
348: wclear(win2);
349: wrefresh(win2);
350: refresh();
351: wrefresh(win1);
352: wclear(win1);
353: print_states(win1);
354: wrefresh(win1);
355: break;
356: }
357:
358: /* if we're not working on a mailfile record, display the Contents
359: * form.
360: */
361: if(strstr(workfile,MAILFILE) == NULL)
362: {
363: display_form(win2);
364: display_record(win2,prevrow,prevcol,screen_num);
365:
366: write_win(win1);
367: wclear(win2);
368: wrefresh(win2);
369: menu();
370: refresh();
371: wrefresh(win1);
372: break;
373: }
374:
375: default:
376: newcol = prevcol;
377: newrow = prevrow;
378: break;
379:
380: }
381:
382: /* print previous file highlited in normal video */
383: lite (win1, prevrow, prevcol, 0,0);
384:
385: /* print new filename selection in inverse video */
386:
387: lite (win1, newrow, newcol, 1,0);
388:
389: /* set our previous coordinates so that we can go back
390: * and unlite a field when the next directin is given.
391: */
392:
393: prevrow = newrow;
394: prevcol = newcol;
395:
396:
397: }
398: while (arrow != 'q');
399:
400: }
401:
402:
403:
404:
405: int rfile()
406:
407: {
408:
409: FILE *infp;
410: int EOF_FLAG;
411:
412:
413: /* open file, abort on error */
414:
415: if ((infp = fopen(workfile,"r")) == NULL)
416: {
417: printf("\007ERROR opening file %s for input!\n", workfile);
418: exit(1);
419: }
420:
421: /* open a file then go to a an offset calculated by a
422: * value passed from the calling program. Once we hit
423: * the max number of records that can be held by a screen,
424: * terminate the read and set a flag to show that we did
425: * not hit EOF. If we did hit EOF, terminate the loop
426: * and set a flag to show that we did hit EOF.
427: */
428:
429: /* start reading from a specified point in the file */
430:
431: if((strstr(workfile,mapfile[0])!= NULL) || (strstr(workfile,mapfile[1])!= NULL) || (strstr(workfile,mapfile[2])!= NULL))
432: fseek(infp,(sizeof (struct map) * (screen_num * 100)),0l);
433: else
434: fseek(infp, (sizeof (struct entry) * (screen_num * 100)), 0l);
435:
436: limit = 0;
437:
438:
439: if((strstr(workfile,mapfile[0])!= NULL) || (strstr(workfile,mapfile[1])!= NULL) || (strstr(workfile,mapfile[2])!= NULL))
440: {
441: while((fread(&map_rec,sizeof(struct map),1,infp)) != 0)
442: {
443: strcpy(filenames[limit], map_rec.name);
444: place[limit] = limit;
445: limit ++;
446: if (limit == 100)
447: break;
448: }
449: }
450: else
451: {
452: while((fread(&record, sizeof(struct entry),1, infp)) != 0)
453: {
454: strcpy(filenames[limit], record.filename);
455: place[limit] = limit;
456: limit++;
457: if (limit == 100)
458: break;
459: }
460: }
461:
462:
463:
464: /* if x made it to 100, then we did NOT hit EOF */
465:
466: if((strstr(workfile,mapfile[0])!= NULL) || (strstr(workfile,mapfile[1])!= NULL) || (strstr(workfile,mapfile[2])!= NULL))
467: {
468: if ( (limit == 100) && (fread (&map_rec,sizeof(struct map),1,infp)) != 0)
469: EOF_FLAG = 0;
470: else
471: EOF_FLAG = -1;
472: }
473: else
474: {
475: if ( (limit == 100) && (fread (&record,sizeof(struct entry),1,infp)) != 0)
476: EOF_FLAG = 0;
477: else
478: EOF_FLAG = -1;
479: }
480: fclose(infp);
481: return (EOF_FLAG);
482:
483: }
484:
485:
486:
487: /*
488: * writewin();
489: * this routine does the actual work of writing filenames to a window
490: */
491:
492: void write_win(win1)
493:
494: WINDOW *win1;
495:
496: {
497:
498: int r,c; /* these are our rows and columns */
499: int counter = 0; /* this counts the number of files written */
500:
501:
502:
503: /* clear the window */
504: wclear(win1);
505:
506: /* the following loop will write the filenames to the window.
507: * 15 characters per screen field are allowed, since a filename
508: * can only be 14 chars in length. This will leave at least one
509: * space between filenames.
510: */
511:
512: for (r = 0; r < 20; r++)
513: {
514:
515: /* if we've run out of files, terminate loop */
516:
517: if (counter == limit)
518: break;
519:
520: /* increment column by 15 positions. This
521: * will cause the filenames to line up
522: * on the window.
523: */
524:
525: for (c = 1; c < 75; c+= 15)
526: {
527: wmove(win1, r, c);
528: waddstr(win1, filenames[counter]);
529:
530: /* increment counter. When it equals the number of
531: * records, passed as 'limit', the loop should
532: * terminate.
533: */
534:
535: counter ++;
536: if (counter == limit)
537: break;
538: }
539: }
540:
541:
542: }
543:
544: /* this function will draw a template for the selected record */
545:
546: void display_form(win2)
547: WINDOW *win2;
548:
549:
550: {
551: int x;
552:
553: clear();
554: wclear(win2);
555:
556: /* print field labels */
557:
558: wmove (win2, NAMELOCATE );
559: waddstr (win2,"Filename:");
560:
561: wmove (win2, DESCLOCATE);
562: waddstr(win2,"Description:");
563:
564: wmove(win2, DATELOCATE );
565: waddstr(win2,"Date added/modified:");
566:
567: wmove(win2, SIZELOCATE);
568: waddstr(win2,"File size:");
569:
570: wmove(win2, REQLOCATE );
571: waddstr(win2,"Requires these other files:");
572:
573: wmove(win2, NOTELOCATE);
574: waddstr(win2,"Other notes:");
575:
576:
577: /* highlite available fields */
578:
579: wstandout(win2);
580:
581: wmove (win2, NAMEHI);
582: waddstr(win2," ");
583:
584: wmove (win2,DESCHI);
585: for (x=1;x<79;x++)
586: waddstr(win2," ");
587:
588: wmove(win2, DATEHI);
589: waddstr(win2," ");
590:
591: wmove(win2, SIZEHI);
592: waddstr(win2," ");
593:
594: wmove (win2,REQHI);
595: for (x=1;x<61;x++)
596: waddstr(win2," ");
597:
598: wmove (win2,NOTEHI);
599: for (x=1;x<69;x++)
600: waddstr(win2," ");
601:
602: wstandend(win2);
603: refresh();
604: wrefresh(win2);
605:
606:
607:
608: }
609:
610: /* following function prints the menu at the bottom of stdscr */
611:
612: void menu()
613:
614: {
615: /* print a menu of options to stdscr. They will appear at the bottom of
616: * the screen with the first letter highlited as an indication to
617: * the user that pressing the highlited key will result in the indicated
618: * action.
619: */
620:
621: move (21,0);
622: if(strstr(workfile,MAILFILE) != NULL)
623: printw("Select state/other to view.");
624: else
625: printw("Select file to download. ");
626: refresh();
627:
628:
629: move(21, 50);
630: standout();
631: printw("Options:");
632: move(22,46);
633: printw("n");
634: move(23,46);
635: printw("p");
636: move(22,60);
637: printw("q");
638: move(23,60);
639: printw("s");
640: standend();
641: move(22,47);
642: addstr("ext page");
643: move(23,47);
644: addstr("rev. page");
645: move(22,61);
646: addstr("uit");
647: move(23,61);
648: addstr("elect file");
649:
650:
651: }
652:
653:
654:
655: /* this function will take the pathname and append the necessary
656: * character(s) to generate the multiple requests necessary to
657: * download multipart files.
658: */
659:
660: void build_uucp(record)
661:
662:
663: {
664: int x,y,z;
665:
666: y = strlen(record.pathname);
667:
668: for(x=0;x< record.noparts;x++){
669: strcpy(getfiles[x],HOST);
670: record.pathname[y] = 97 + x;
671: record.pathname[y+1] = '\0';
672: strcat(getfiles[x],record.pathname);
673: strcat(getfiles[x],recdir);
674:
675: for(z=strlen(getfiles[x]) ; z < sizeof(getfiles[x]) ; z++){
676: getfiles[x][z] = '\0';
677: }
678:
679: }
680:
681:
682: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.