开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > TCP/IP协议栈 > 查看源码
main.c
资源名称：export.zip　[点击查看]
上传用户：hepax88
上传日期：2007-01-03
资源大小：1101k
文件大小：16k
源码类别：

TCP/IP协议栈

开发平台：

Visual C++

main.c：源码内容
  1. /* Main-level NOS program:
  2.  *  initialization
  3.  *  keyboard processing
  4.  *  generic user commands
  5.  *
  6.  * Copyright 1986-1995 Phil Karn, KA9Q
  7.  */
  8. #include <stdio.h>
  9. #include <time.h>
  10. #include <ctype.h>
  11. #if defined(__TURBOC__) && defined(MSDOS)
  12. #include <io.h>
  13. #include <conio.h>
  14. #endif
  15. #include "global.h"
  16. #include <stdarg.h>
  17. #include "mbuf.h"
  18. #include "timer.h"
  19. #include "proc.h"
  20. #include "iface.h"
  21. #include "ip.h"
  22. #include "tcp.h"
  23. #include "udp.h"
  24. #include "ax25.h"
  25. #include "kiss.h"
  26. #include "enet.h"
  27. #include "netrom.h"
  28. #include "ftpcli.h"
  29. #include "telnet.h"
  30. #include "tty.h"
  31. #include "session.h"
  32. #include "hardware.h"
  33. #include "usock.h"
  34. #include "socket.h"
  35. #include "cmdparse.h"
  36. #include "commands.h"
  37. #include "daemon.h"
  38. #include "devparam.h"
  39. #include "domain.h"
  40. #include "files.h"
  41. #include "main.h"
  42. #include "remote.h"
  43. #include "trace.h"
  44. #include "display.h"
  46. extern struct cmds Cmds[],Startcmds[],Stopcmds[],Attab[];
  48. #ifndef MSDOS /* PC uses F-10 key always */
  49. static char Escape = 0x1d; /* default escape character is ^] */
  50. #endif
  52. char Badhost[] = "Unknown host %sn";
  53. char *Hostname;
  54. char Nospace[] = "No space!!n"; /* Generic malloc fail message */
  55. struct proc *Cmdpp;
  56. struct proc *Display;
  57. char *Cmdline; /* Copy of most recent command line */
  58. int main_exit = FALSE; /* from main program (flag) */
  60. static char Prompt[] = "net> ";
  61. static FILE *Logfp;
  62. static time_t StartTime; /* time that NOS was started */
  63. static int Verbose;
  65. static int keychar(int c);
  66. static void pass(char *,int len);
  67. static void passchar(int c);
  69. int
  70. main(argc,argv)
  71. int argc;
  72. char *argv[];
  73. {
  74. FILE *fp;
  75. struct daemon *tp;
  76. int c;
  77. char cmdbuf[256];
  78. long hinit = 102400;
  79. unsigned chunk;
  80. void **list;
  82. StartTime = time(&StartTime);
  84. while((c = getopt(argc,argv,"f:s:d:bvh:")) != EOF){
  85. switch(c){
  86. case 'h': /* Heap initialization */
  87. hinit = atol(optarg);
  88. break;
  89. case 'f': /* Number of files */
  90. Nfiles = atoi(optarg);
  91. break;
  92. case 's': /* Number of sockets */
  93. Nsock = atoi(optarg);
  94. break;
  95. case 'd': /* Root directory for various files */
  96. initroot(optarg);
  97. break;
  98. #ifdef __TURBOC__
  99. case 'b': /* Use BIOS for screen output */
  100. directvideo = 0;
  101. break;
  102. #endif
  103. case 'v':
  104. Verbose = 1;
  105. break;
  106. }
  107. }
  108. /* Get some memory on the heap so interrupt calls to malloc
  109.  * won't fail unnecessarily
  110.  */
  111. list = calloc(sizeof(void *),(hinit / 32768L) + 1);
  112. for(c=0;hinit > 0;hinit -= chunk){
  113. chunk = min(hinit,32768U);
  114. list[c++] = malloc(chunk);
  115. }
  116. while(c > 0)
  117. free(list[--c]);
  118. free(list);
  120. kinit();
  121. ipinit();
  122. ioinit();
  123. sockinit();
  124. Cmdpp = mainproc("cmdintrp");
  126. Sessions = (struct session **)callocw(Nsessions,sizeof(struct session *));
  127. Command = Lastcurr = newsession("command interpreter",COMMAND,1);
  128. Display = newproc("display",350,display,0,NULL,NULL,0);
  129. printf("KA9Q NOS version %sn",Version);
  130. #ifdef CPU386
  131. printf("Compiled for 386/486 CPUn");
  132. #endif
  133. printf("Copyright 1986-1995 by Phil Karn, KA9Qn");
  134. usercvt();
  135. /* Start background Daemons */
  136. for(tp=Daemons;;tp++){
  137. if(tp->name == NULL)
  138. break;
  139. newproc(tp->name,tp->stksize,tp->fp,0,NULL,NULL,0);
  140. }
  141. Encap.txproc = newproc("encap tx",512,if_tx,0,&Encap,NULL,0);
  142. if(optind < argc){
  143. /* Read startup file named on command line */
  144. if((fp = fopen(argv[optind],READ_TEXT)) == NULL){
  145. printf("Can't read config file %s",argv[optind]);
  146. perror("");
  147. }
  148. } else {
  149. fp = fopen(Startup,READ_TEXT);
  150. }
  151. if(fp != NULL){
  152. while(fgets(cmdbuf,sizeof(cmdbuf),fp) != NULL){
  153. rip(cmdbuf);
  154. if(Cmdline != NULL)
  155. free(Cmdline);
  156. Cmdline = strdup(cmdbuf);
  157. if(Verbose)
  158. printf("%sn",Cmdline);
  159. if(cmdparse(Cmds,cmdbuf,NULL) != 0){
  160. printf("input line: %sn",Cmdline);
  161. }
  162. }
  163. fclose(fp);
  164. }
  165. /* Now loop forever, processing commands */
  166. for(;;){
  167. printf(Prompt);
  168. fflush(stdout);
  169. if(fgets(cmdbuf,sizeof(cmdbuf),stdin) != NULL){
  170. rip(cmdbuf);
  171. if(Cmdline)
  172. free(Cmdline);
  173. Cmdline = strdup(cmdbuf);
  174. (void)cmdparse(Cmds,cmdbuf,Lastcurr);
  175. }
  176. }
  177. }
  178. /* Keyboard input process */
  179. void
  180. keyboard(i,v1,v2)
  181. int i;
  182. void *v1;
  183. void *v2;
  184. {
  185. int c;
  186. int j;
  188. /* Keyboard process loop */
  189. loop:
  190. c = kbread();
  191. #ifdef MSDOS
  192. if(c >= 256){
  193. /* Pass all special characters to app upcall */
  194. if(Current->ctlproc != NULL && (c = (*Current->ctlproc)(c)) == 0)
  195. goto loop; /* Upcall took them */
  197. c -= 256;
  198. if(Current->scrollmode == SCROLL_INBAND){
  199. /* In inband scroll mode, pass escape sequences
  200.  * for cursor control keys. Otherwise fall thru
  201.  */ 
  202. switch(c){
  203. case CURSHOM:
  204. pass("33O",3);
  205. goto loop;
  206. case CURSUP:
  207. pass("33OA",3);
  208. goto loop;
  209. case PAGEUP:
  210. pass("33[5~",4);
  211. goto loop;
  212. case CURSEND:
  213. pass("33OU",3);
  214. goto loop;
  215. case CURSDWN:
  216. pass("33OB",3);
  217. goto loop;
  218. case PAGEDWN:
  219. pass("33[6~",4);
  220. goto loop;
  221. case CURSRIGHT:
  222. pass("33OC",3);
  223. goto loop;
  224. case CURSLEFT:
  225. pass("33OD",3);
  226. goto loop;
  227. }
  228. }
  229. /* In local scroll mode, we can get here with cursor
  230.  * control keys
  231.  */
  232. switch(c){
  233. case CURSHOM:
  234. dhome(Current->output->ptr);
  235. break;
  236. case CURSUP:
  237. dcursup(Current->output->ptr);
  238. break;
  239. case PAGEUP:
  240. dpgup(Current->output->ptr);
  241. break;
  242. case CURSEND:
  243. dend(Current->output->ptr);
  244. break;
  245. case CURSDWN:
  246. dcursdown(Current->output->ptr);
  247. break;
  248. case PAGEDWN:
  249. dpgdown(Current->output->ptr);
  250. break;
  251. case F10: /* F-10 (go to command mode) */
  252. if(Current != Command){
  253. /* Save current tty mode and set cooked */
  254. Lastcurr = Current;
  255. Current = Command;
  256. alert(Display,1);
  257. }
  258. break;
  259. case F9: /* F-9 (resume last current session) */
  260. if(Current == Command && Lastcurr != NULL){
  261. Current = Lastcurr;
  262. alert(Display,1);
  263. }
  264. break;
  265. case F8: /* F-8 (next session) */
  266. for(j = Current->index+1;j != Current->index;j++){
  267. if(j >= Nsessions)
  268. j = 0;
  269. if(Sessions[j] != NULL){
  270. Current = Sessions[j];
  271. alert(Display,1);
  272. break;
  273. }
  274. }
  275. break;
  276. case F7: /* F-7 (prev session) */
  277. for(j = Current->index-1;j != Current->index;j--){
  278. if(j == -1)
  279. j = Nsessions-1;
  280. if(Sessions[j] != NULL){
  281. Current = Sessions[j];
  282. alert(Display,1);
  283. break;
  284. }
  285. }
  286. break;
  287. case F6: /* Toggle scroll mode */
  288. if(Current == NULL)
  289. break;
  290. Current->scrollmode = !Current->scrollmode;
  291. dscrollmode(Current->output->ptr,Current->scrollmode);
  292. break;
  293. case F5: /* Kick current session */
  294. if(Current != NULL)
  295. dokick(0,NULL,Current);
  296. break;
  297. case AF1:
  298. case AF2:
  299. case AF3:
  300. case AF4:
  301. case AF5:
  302. case AF6:
  303. case AF7:
  304. case AF8:
  305. case AF9:
  306. case AF10: /* Alt-F1 thru Alt-F10 */
  307. c -= 103;
  308. if(c < Nsessions && Sessions[c] != NULL){
  309. Current = Sessions[c];
  310. alert(Display,1);
  311. }
  312. break;
  313. case AF11: /* Alt-F11 or Alt-F12 */
  314. case AF12:
  315. c -= 128;
  316. if(c < Nsessions && Sessions[c] != NULL){
  317. Current = Sessions[c];
  318. alert(Display,1);
  319. }
  320. break;
  321. default: /* else ignore */
  322. break;
  323. }
  324. goto loop;
  325. }
  326. #else
  327. if(c == Escape && Escape != 0 && Current != Command){
  328. /* Save current tty mode and set cooked */
  329. Lastcurr = Current;
  330. Current = Command;
  331. alert(Display,1);
  332. goto loop;
  333. }
  334. #endif
  335. passchar(c);
  336. goto loop;
  337. }
  338. static void
  339. pass(s,len)
  340. char *s;
  341. int len;
  342. {
  343. while(len-- != 0)
  344. passchar(*s++);
  345. }
  347. static void
  348. passchar(c)
  349. int c;
  350. {
  351. int cnt;
  353. /* If a normal-character upcall exists, give it the character.
  354.  * if the upcall returns 0, don't pass it to the regular tty editor
  355.  */
  356. if(Current->inproc != NULL && (*Current->inproc)(c) == 0)
  357. return;
  359. /* Ordinary ASCII character, hand to tty editor */
  360. if((cnt = ttydriv(Current,(char)c)) != 0){
  361. /* Input ready to hand to process */
  362. fwrite(Current->ttystate.line,1,cnt,Current->input);
  363. fflush(Current->input);
  364. }
  365. }
  366. /* Standard commands called from main */
  367. int
  368. dorepeat(argc,argv,p)
  369. int argc;
  370. char *argv[];
  371. void *p;
  372. {
  373. int32 interval;
  374. int ret;
  375. struct session *sp;
  377. if(isdigit(argv[1][0])){
  378. interval = atol(argv[1]);
  379. argc--;
  380. argv++;
  381. } else {
  382. interval = MSPTICK;
  383. }
  384. if((sp = newsession(Cmdline,REPEAT,1)) == NULL){
  385. printf("Too many sessionsn");
  386. return 1;
  387. }
  388. sp->inproc = keychar; /* Intercept ^C */
  389. /* Set enough buffering to handle an entire screen so it'll get
  390.  * displayed in one quick update when we flush
  391.  */
  392. setvbuf(sp->output,NULL,_IOFBF,2048);
  393. while(sp->inproc == keychar){ /* ^C will clear sp->inproc */
  394. printf("%c[2J",ESC); /* Clear screen */
  395. ret = subcmd(Cmds,argc,argv,p);
  396. fflush(sp->output);
  397. if(ret != 0 || ppause(interval) == -1)
  398. break;
  399. }
  400. keywait(NULL,1);
  401. freesession(sp);
  402. return 0;
  403. }
  404. static int
  405. keychar(c)
  406. int c;
  407. {
  408. if(c != CTLC)
  409. return 1; /* Ignore all but ^C */
  411. fprintf(Current->output,"^Cn");
  412. alert(Current->proc,EABORT);
  413. Current->inproc = NULL;
  414. return 0;
  415. }
  417. int
  418. dodelete(argc,argv,p)
  419. int argc;
  420. char *argv[];
  421. void *p;
  422. {
  423. int i;
  425. for(i=1;i < argc; i++){
  426. if(unlink(argv[i]) == -1){
  427. printf("Can't delete %s",argv[i]);
  428. perror("");
  429. }
  430. }
  431. return 0;
  432. }
  433. int
  434. dorename(argc,argv,p)
  435. int argc;
  436. char *argv[];
  437. void *p;
  438. {
  439. if(rename(argv[1],argv[2]) == -1){
  440. printf("Can't rename %s",argv[1]);
  441. perror("");
  442. }
  443. return 0;
  444. }
  445. int
  446. doexit(argc,argv,p)
  447. int argc;
  448. char *argv[];
  449. void *p;
  450. {
  451. int i;
  452. time_t StopTime;
  453. struct session *sp;
  455. StopTime = time(&StopTime);
  456. main_exit = TRUE; /* let everyone know we're out of here */
  457. /* Alert each session task that we're aborting */
  458. for(i=0;i<Nsessions;i++){
  459. if((sp = Sessions[i]) == NULL)
  460. continue;
  461. alert(sp->proc,EABORT);
  462. alert(sp->proc1,EABORT);
  463. alert(sp->proc2,EABORT);
  464. }
  465. reset_all();
  466. if(Dfile_updater != NULL)
  467. alert(Dfile_updater,0); /* don't wait for timeout */
  468. for(i=0;i<100;i++)
  469. kwait(NULL); /* Allow tasks to complete */
  470. shuttrace();
  471. logmsg(-1,"NOS was stopped at %s", ctime(&StopTime));
  472. if(Logfp){
  473. fclose(Logfp);
  474. Logfp = NULL;
  475. }
  476. clrscr();
  477. iostop();
  478. exit(0);
  479. return 0; /* To satisfy lint */
  480. }
  481. int
  482. dohostname(argc,argv,p)
  483. int argc;
  484. char *argv[];
  485. void *p;
  486. {
  487. if(argc < 2)
  488. printf("%sn",Hostname);
  489. else {
  490. struct iface *ifp;
  491. char *name;
  493. if((ifp = if_lookup(argv[1])) != NULL){
  494. if((name = resolve_a(ifp->addr, FALSE)) == NULL){
  495. printf("Interface address not resolvedn");
  496. return 1;
  497. } else {
  498. if(Hostname != NULL)
  499. free(Hostname);
  500. Hostname = name;
  502. /* remove trailing dot */
  503. if ( Hostname[strlen(Hostname)] == '.' ) {
  504. Hostname[strlen(Hostname)] = '';
  505. }
  506. printf("Hostname set to %sn", name );
  507. }
  508. } else {
  509. if(Hostname != NULL)
  510. free(Hostname);
  511. Hostname = strdup(argv[1]);
  512. }
  513. }
  514. return 0;
  515. }
  516. int
  517. dolog(argc,argv,p)
  518. int argc;
  519. char *argv[];
  520. void *p;
  521. {
  522. static char *logname;
  524. if(argc < 2){
  525. if(Logfp)
  526. printf("Logging to %sn",logname);
  527. else
  528. printf("Logging offn");
  529. return 0;
  530. }
  531. if(Logfp){
  532. logmsg(-1,"NOS log closed");
  533. fclose(Logfp);
  534. Logfp = NULL;
  535. free(logname);
  536. logname = NULL;
  537. }
  538. if(strcmp(argv[1],"stop") != 0){
  539. logname = strdup(argv[1]);
  540. Logfp = fopen(logname,APPEND_TEXT);
  541. logmsg(-1,"NOS was started at %s", ctime(&StartTime));
  542. }
  543. return 0;
  544. }
  545. int
  546. dohelp(argc,argv,p)
  547. int argc;
  548. char *argv[];
  549. void *p;
  550. {
  551. register struct cmds *cmdp;
  552. int i;
  553. char buf[66];
  555. printf("Main commands:n");
  556. memset(buf,' ',sizeof(buf));
  557. buf[64] = 'n';
  558. buf[65] = '';
  559. for(i=0,cmdp = Cmds;cmdp->name != NULL;cmdp++,i = (i+1)%4){
  560. strncpy(&buf[i*16],cmdp->name,strlen(cmdp->name));
  561. if(i == 3){
  562. printf(buf);
  563. memset(buf,' ',sizeof(buf));
  564. buf[64] = 'n';
  565. buf[65] = '';
  566. }
  567. }
  568. if(i != 0)
  569. printf(buf);
  570. return 0;
  571. }
  572. /* Attach an interface
  573.  * Syntax: attach <hw type> <I/O address> <vector> <mode> <label> <bufsize> [<speed>]
  574.  */
  575. int
  576. doattach(argc,argv,p)
  577. int argc;
  578. char *argv[];
  579. void *p;
  580. {
  581. return subcmd(Attab,argc,argv,p);
  582. }
  583. /* Manipulate I/O device parameters */
  584. int
  585. doparam(argc,argv,p)
  586. int argc;
  587. char *argv[];
  588. void *p;
  589. {
  590. register struct iface *ifp;
  591. int param;
  592. int32 val;
  594. if((ifp = if_lookup(argv[1])) == NULL){
  595. printf("Interface "%s" unknownn",argv[1]);
  596. return 1;
  597. }
  598. if(ifp->ioctl == NULL){
  599. printf("Not supportedn");
  600. return 1;
  601. }
  602. if(argc < 3){
  603. for(param=1;param<=16;param++){
  604. val = (*ifp->ioctl)(ifp,param,FALSE,0L);
  605. if(val != -1)
  606. printf("%s: %ldn",parmname(param),val);
  607. }
  608. return 0;
  609. }
  610. if((param = devparam(argv[2])) == -1){
  611. printf("Unknown parameter %sn",argv[2]);
  612. return 1;
  613. }
  614. if(argc < 4){
  615. /* Read specific parameter */
  616. val = (*ifp->ioctl)(ifp,param,FALSE,0L);
  617. if(val == -1){
  618. printf("Parameter %s not supportedn",argv[2]);
  619. } else {
  620. printf("%s: %ldn",parmname(param),val);
  621. }
  622. return 0;
  623. }
  624. /* Set parameter */
  625. (*ifp->ioctl)(ifp,param,TRUE,atol(argv[3]));
  626. return 0;
  627. }
  629. #ifndef MSDOS
  630. int
  631. doescape(argc,argv,p)
  632. int argc;
  633. char *argv[];
  634. void *p;
  635. {
  636. if(argc < 2)
  637. printf("0x%xn",Escape);
  638. else
  639. Escape = *argv[1];
  640. return 0;
  641. }
  642. #endif MSDOS
  643. /* Generate system command packet. Synopsis:
  644.  * remote [-p port#] [-k key] [-a hostname] <hostname> reset|exit|kickme
  645.  */
  646. int
  647. doremote(argc,argv,p)
  648. int argc;
  649. char *argv[];
  650. void *p;
  651. {
  652. struct sockaddr_in fsock;
  653. int s,c;
  654. uint8 *data,x;
  655. uint16 port,len;
  656. char *key = NULL;
  657. int klen;
  658. int32 addr = 0;
  659. char *cmd,*host;
  661. port = IPPORT_REMOTE; /* Set default */
  662. optind = 1; /* reinit getopt() */
  663. while((c = getopt(argc,argv,"a:p:k:s:")) != EOF){
  664. switch(c){
  665. case 'a':
  666. addr = resolve(optarg);
  667. break;
  668. case 'p':
  669. port = atoi(optarg);
  670. break;
  671. case 'k':
  672. key = optarg;
  673. klen = strlen(key);
  674. break;
  675. case 's':
  676. Rempass = strdup(optarg);
  677. return 0; /* Only set local password */
  678. }
  679. }
  680. if(optind > argc - 2){
  681. printf("Insufficient argsn");
  682. return -1;
  683. }
  684. host = argv[optind++];
  685. cmd = argv[optind];
  686. if((s = socket(AF_INET,SOCK_DGRAM,0)) == -1){
  687. perror("socket failed");
  688. return 1;
  689. }
  690. len = 1;
  691. /* Did the user include a password or kickme target? */
  692. if(addr != 0)
  693. len += sizeof(int32);
  695. if(key != NULL)
  696. len += klen;
  698. if(len == 1)
  699. data = &x;
  700. else
  701. data = mallocw(len);
  703. fsock.sin_family = AF_INET;
  704. fsock.sin_addr.s_addr = resolve(host);
  705. fsock.sin_port = port;
  707. switch(cmd[0]){
  708. case 'r':
  709. data[0] = SYS_RESET;
  710. if(key != NULL)
  711. strncpy((char *)&data[1],key,klen);
  712. break;
  713. case 'e':
  714. data[0] = SYS_EXIT;
  715. if(key != NULL)
  716. strncpy((char *)&data[1],key,klen);
  717. break;
  718. case 'k':
  719. data[0] = KICK_ME;
  720. if(addr != 0)
  721. put32(&data[1],addr);
  722. break;
  723. default:
  724. printf("Unknown command %sn",cmd);
  725. goto cleanup;
  726. }
  727. /* Form the command packet and send it */
  728. if(sendto(s,data,len,0,(struct sockaddr *)&fsock,sizeof(fsock)) == -1){
  729. perror("sendto failed");
  730. goto cleanup;
  731. }
  732. cleanup:
  733. if(data != &x)
  734. free(data);
  735. close_s(s);
  736. return 0;
  737. }
  739. /* Execute a command with output piped to more */
  740. int
  741. dopage(argc,argv,p)
  742. int argc;
  743. char *argv[];
  744. void *p;
  745. {
  746. FILE *fp;
  747. FILE *outsav;
  749. fp = tmpfile();
  750. outsav = stdout;
  751. stdout = fp;
  752. subcmd(Cmds,argc,argv,p);
  753. stdout = outsav;
  754. newproc("view",512,view,0,(void *)fp,NULL,0); /* View closes fp */
  755. return 0;
  756. }
  758. /* Set kernel process debug flag */
  759. int
  760. dodebug(argc,argv,p)
  761. int argc;
  762. char *argv[];
  763. void *p;
  764. {
  765. setbool(&Kdebug,"kernel debug",argc,argv);
  766. return 0;
  767. }
  768. /* Set temp file wipe-on-close flag */
  769. int
  770. dowipe(argc,argv,p)
  771. int argc;
  772. char *argv[];
  773. void *p;
  774. {
  775. setbool(&_clrtmp,"tmp file wiping",argc,argv);
  776. return 0;
  777. }
  779. /* No-op command */
  780. int
  781. donothing(argc,argv,p)
  782. int argc;
  783. char *argv[];
  784. void *p;
  785. {
  786. return 0;
  787. }
  789. /* Log messages of the form
  790.  * Tue Jan 31 00:00:00 1987 44.64.0.7:1003 open FTP
  791.  */
  792. void
  793. logmsg(int s,char *fmt, ...)
  794. {
  795. va_list ap;
  796. char *cp;
  797. long t;
  798. int i;
  799. struct sockaddr fsocket;
  800. #ifdef MSDOS
  801. int fd;
  802. #endif
  804. if(Logfp == NULL)
  805. return;
  807. time(&t);
  808. cp = ctime(&t);
  809. rip(cp);
  810. i = SOCKSIZE;
  811. fprintf(Logfp,"%s",cp);
  812. if(getpeername(s,&fsocket,&i) != -1)
  813. fprintf(Logfp," %s",psocket(&fsocket));
  815. fprintf(Logfp," - ");
  816. va_start(ap,fmt);
  817. vfprintf(Logfp,fmt,ap);
  818. va_end(ap);
  819. fprintf(Logfp,"n");
  820. fflush(Logfp);
  821. #ifdef MSDOS
  822. /* MS-DOS doesn't really flush files until they're closed */
  823. fd = fileno(Logfp);
  824. if((fd = dup(fd)) != -1)
  825. close(fd);
  826. #endif
  827. }