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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 查看源码
ckuusx.c
资源名称：cku197.tar.Z　[点击查看]
上传用户：dufan58
上传日期：2007-01-05
资源大小：3407k
文件大小：192k
源码类别：

通讯/手机编程

开发平台：

Windows_Unix

ckuusx.c：源码内容
  1.             }
  2.             if (n == 0)
  3.               goto xdebug;
  5.             m = n + 32;                 /* m = size of dest */
  7.             pbuf = (char *) malloc(m+1);
  8.             if (!pbuf)
  9.               goto xdebug;
  10.             i = 0;
  11.             pbuf[i++] = '[';
  12.             for (; i <= n; p++) {
  13.                 if (*p == LF) {
  14.                     if (i >= m-4)
  15.                       break;
  16.                     pbuf[i++] = '<';
  17.                     pbuf[i++] = 'L';
  18.                     pbuf[i++] = 'F';
  19.                     pbuf[i++] = '>';
  20.                     continue;
  21.                 } else if (*p) {
  22.                     pbuf[i++] = *p;
  23.                     continue;
  24.                 } else {
  25.                     if (i >= m-5)
  26.                       break;
  27.                     pbuf[i++] = '<';
  28.                     pbuf[i++] = 'N';
  29.                     pbuf[i++] = 'U';
  30.                     pbuf[i++] = 'L';
  31.                     pbuf[i++] = '>';
  32.                     continue;
  33.                 }
  34.             }
  35.             if (i < m-2 || contd) {
  36.                 pbuf[i++] = '.';
  37.                 pbuf[i++] = '.';
  38.             }
  39.             pbuf[i++] = ']';
  40. #ifdef COMMENT
  41.             pbuf[i] = NUL;
  42. #else
  43.             sprintf(pbuf+i,"=%ld",n);
  44. #endif /*  */
  45.             if (!s1) s1 = "";
  46.             if (*s1) {
  47.                 if (zsout(ZDFILE,s1) < 0) {
  48.                     deblog = 0;
  49.                     zclose(ZDFILE);
  50.                 }
  51.             }
  52.             if (zsoutl(ZDFILE,pbuf) < 0) {
  53.                 deblog = 0;
  54.                 zclose(ZDFILE);
  55.             }
  56. #ifdef CKSYSLOG
  57.             if (ckxsyslog >= SYSLG_DB && ckxlogging) {
  58.                 cksyslog(SYSLG_DB,1,"debug",s1,pbuf);
  59.             }
  60. #endif /* CKSYSLOG */
  61.             free(pbuf);
  62.         }
  63. #endif /* DEBUG */
  64. #endif /* COMMENT */
  65.         break;
  66.       case F100:                        /* 4, "s1" */
  67.         if (zsoutl(ZDFILE,s1) < 0) {
  68.             deblog = 0;
  69.             zclose(ZDFILE);
  70.         }
  71. #ifdef CKSYSLOG
  72.         if (ckxsyslog >= SYSLG_DB && ckxlogging) {
  73.             cksyslog(SYSLG_DB,1,"debug",s1,NULL);
  74.         }
  75. #endif /* CKSYSLOG */
  76.         break;
  77.       case F101:                        /* 5, "s1=n" */
  78.         sprintf(sp,"%s=%ldn",s1,n);
  79.         if (zsout(ZDFILE,dbptr) < 0) {
  80.             deblog = 0;
  81.             zclose(ZDFILE);
  82.         }
  83. #ifdef CKSYSLOG
  84.         if (ckxsyslog >= SYSLG_DB && ckxlogging) {
  85.             cksyslog(SYSLG_DB,1,"debug",dbptr,NULL);
  86.         }
  87. #endif /* CKSYSLOG */
  88.         break;
  89.       case F110:                        /* 6, "s1[s2]" */
  90.         sprintf(sp,"%s[%s]n",s1,s2);
  91.         if (zsout(ZDFILE,dbptr) < 0) {
  92.             deblog = 0;
  93.             zclose(ZDFILE);
  94.         }
  95. #ifdef CKSYSLOG
  96.         if (ckxsyslog >= SYSLG_DB && ckxlogging) {
  97.             cksyslog(SYSLG_DB,1,"debug",dbptr,NULL);
  98.         }
  99. #endif /* CKSYSLOG */
  100.         break;
  101.       case F111:                        /* 7, "s1[s2]=n" */
  102.         sprintf(sp,"%s[%s]=%ldn",s1,s2,n);
  103.         if (zsout(ZDFILE,dbptr) < 0) {
  104.             deblog = 0;
  105.             zclose(ZDFILE);
  106.         }
  107. #ifdef CKSYSLOG
  108.         if (ckxsyslog >= SYSLG_DB && ckxlogging) {
  109.             cksyslog(SYSLG_DB,1,"debug",dbptr,NULL);
  110.         }
  111. #endif /* CKSYSLOG */
  112.         break;
  113.       default:
  114.         sprintf(sp,"n?Invalid format for debug() - %dn",f);
  115.         if (zsout(ZDFILE,dbptr) < 0) {
  116.             deblog = 0;
  117.             zclose(ZDFILE);
  118.         }
  119. #ifdef CKSYSLOG
  120.         if (ckxsyslog >= SYSLG_DB && ckxlogging) {
  121.             cksyslog(SYSLG_DB,1,"debug",dbptr,NULL);
  122.         }
  123. #endif /* CKSYSLOG */
  124.         break;
  125.     }
  126.   xdebug:                               /* Common exit point */
  127. #ifndef OS2
  128.     deblog = 1;                         /* Restore this */
  129. #endif /* OS2 */
  130.     return(0);
  131. }
  133. VOID
  134. #ifdef CK_ANSIC
  135. dohexdump(CHAR *msg, CHAR *st, int cnt)
  136. #else
  137. dohexdump(msg,st,cnt) CHAR *msg; CHAR *st; int cnt;
  138. #endif /* CK_ANSIC */
  139. /* dohexdump */ {
  140.     int i = 0, j = 0;
  141.     char tmp[8];
  143.     if (!deblog) return;                /* If no debug log, don't. */
  144.     if (!dbptr) {                       /* Allocate memory buffer */
  145.         dbptr = malloc(DBUFL+1);        /* This only happens once */
  146.         if (!dbptr) {
  147.             deblog = 0;
  148.             zclose(ZDFILE);
  149.             return;
  150.         }
  151.     }
  152.     if (msg != NULL) {
  153.         sprintf(dbptr,"HEXDUMP: %s (%d bytes)n",msg,cnt);
  154.         if (zsout(ZDFILE,dbptr) < 0) {
  155.             deblog = 0;
  156.             zclose(ZDFILE);
  157.             return;
  158.         }
  159.     } else {
  160.         sprintf(dbptr,"HEXDUMP: (%d bytes)n",cnt);
  161.         zsout(ZDFILE,dbptr);
  162.         if (zsout(ZDFILE,dbptr) < 0) {
  163.             deblog = 0;
  164.             zclose(ZDFILE);
  165.             return;
  166.         }
  167.     }
  168.     for (i = 0; i < cnt; i++) {
  169.         dbptr[0] = '';
  170.         for(j = 0 ; (j < 16) && ((i + j) < cnt) ; j++) {
  171.             sprintf(tmp,
  172.                     "%s%02x%s",
  173.                     (j == 8 ? "| " : ""),
  174.                     (CHAR) st[i + j],
  175.                     (j < 16 && i < cnt ? "  " : "")
  176.                     );
  177.             strcat(dbptr,tmp);
  178.         }
  179.         strcat(dbptr,"n");
  180.         i += j - 1;
  181.         if (zsout(ZDFILE,dbptr) < 0) {
  182.             deblog = 0;
  183.             zclose(ZDFILE);
  184.             return;
  185.         }
  186.     } /* end for */
  187. }
  188. #endif /* DEBUG */
  190. VOID
  191. #ifdef OS2
  192. logchar(unsigned short c)
  193. #else /* OS2 */
  194. #ifdef CK_ANSIC
  195. logchar(char c)
  196. #else
  197. logchar(c) char c;
  198. #endif /* CK_ANSIC */
  199. #endif /* OS2 */
  200. /* logchar */ {                         /* Log character c to session log */
  201. #ifndef NOLOCAL
  202.     if (seslog)
  203.       if ((sessft != XYFT_T) ||
  204.           (c != 'r' &&
  205.            c != '' &&
  206.            c != XON &&
  207.            c != XOFF))
  208.         if (zchout(ZSFILE,(CHAR)(c & 0xFF)) < 0) {
  209.             conoll("");
  210.             conoll("ERROR WRITING SESSION LOG, LOG CLOSED!");
  211.             seslog = 0;
  212.             zclose(ZSFILE);
  213.         }
  214. #endif /* NOLOCAL */
  215. }
  217. VOID
  218. logstr(s, len) char * s; int len; {     /* Log string to session log */
  219. #ifndef NOLOCAL
  220.     char c;
  221.     int n = 0;
  222.     if (!seslog || !s)
  223.       return;
  224.     while (n < len) {
  225.         c = s[n];
  226.         n++;
  227.         if ((sessft != XYFT_T) ||
  228.             (c != 'r' &&
  229.              c != '' &&
  230.              c != XON &&
  231.              c != XOFF))
  232.           if (zchout(ZSFILE,c) < 0) {
  233.               conoll("");
  234.               conoll("ERROR WRITING SESSION LOG, LOG CLOSED!");
  235.               seslog = 0;
  236.               zclose(ZSFILE);
  237.               return;
  238.           }
  239.     }
  240. #endif /* NOLOCAL */
  241. }
  243. #ifdef CK_CURSES
  244. #ifdef STRATUS
  245. /* VOS has curses but no tgetent() */
  246. int
  247. tgetent(s1, s2) char * s1, * s2; {
  248.     return(1);
  249. }
  250. #endif /* STRATUS */
  252. #ifdef VMS
  253. #ifdef __DECC
  254. _PROTOTYP(int tgetent,(char *, char *));
  255. #endif /* __DECC */
  256. #endif /* VMS */
  258. /*
  259.   There are three different ways to do fullscreen on VMS.
  260.   1. Use the real curses library, VAXCCURSE.
  261.   2. Use do-it-yourself code.
  262.   3. Use the Screen Manager, SMG$.
  264.   Method 1 doesn't work quite right; you can't call endwin(), so once you've
  265.   started curses mode, you can never leave.
  267.   Method 2 doesn't optimize the screen, and so much more time is spent in
  268.   screen writes.  This actually causes file transfers to fail because the
  269.   tty device input buffer can be overrun while the screen is being updated,
  270.   especially on a slow MicroVAX that has small typeahead buffers.
  272.   In the following #ifdef block, #define one of them and #undef the other 2.
  274.   So now let's try method 3...
  275. */
  276. #ifdef VMS
  277. #define CK_SMG                          /* Screen Manager */
  278. #undef MYCURSES                         /* Do-it-yourself */
  279. #undef VMSCURSE                         /* VAXCCURSE library */
  280. #endif /* VMS */
  281. /*
  282.   But just before New Years, 2000, the SMG library seemed to break on
  283.   both VMS systems we have here (an Alpha with VMS 7.1 and a VAX with 5.5).
  284.   So back to MYCURSES, which works fine.
  285. */
  286. #ifdef VMS
  287. #undef CK_SMG
  288. #define MYCURSES
  289. #endif /* VMS */
  291. #ifdef MYCURSES
  292. #define stdscr 0
  293. #ifdef CK_WREFRESH
  294. #undef CK_WREFRESH
  295. #endif /* CK_WREFRESH */
  296. #endif /* MYCURSES */
  298. /*  S C R E E N C  --  Screen display function, uses curses  */
  300. /* Idea for curses display contributed by Chris Pratt of APV Baker, UK */
  302. /* Avoid conficts with curses.h */
  304. #ifdef QNX
  305. /* Same as ckcasc.h, but in a different radix... */
  306. #ifdef ESC
  307. #undef ESC
  308. #endif /* ESC */
  309. #endif /* QNX */
  311. #ifndef MYCURSES
  312. #undef VOID                             /* This was defined in ckcdeb.h */
  313. #endif /* MYCURSES */
  315. #undef BS                               /* These were defined in ckcasc.h */
  316. #undef CR
  317. #undef NL
  318. #undef SO
  319. #undef US
  320. #undef SP                               /* Used in ncurses */
  321. #define CHR_SP 32                       /* Use this instead */
  323. #ifdef VMS                              /* VMS fullscreen display */
  324. #ifdef MYCURSES                         /* Do-it-yourself method */
  325. extern int isvt52;                      /* From CKVTIO.C */
  326. #define printw printf
  327. #else
  328. #ifdef VMSCURSE                         /* VMS curses library VAXCCURSE */
  329. #include <curses.h>
  330. /* Note: Screen manager doesn't need a header file */
  331. #endif /* VMSCURSE */
  332. #endif /* MYCURSES */
  333. #else                                   /* Not VMS */
  334. #ifdef MYCURSES                         /* Do-it-yourself method */
  335. #define isvt52 0                        /* Used by OS/2, VT-100/ANSI always */
  336. #ifdef CKXPRINTF
  337. #define printw ckxprintf
  338. #else /* CKXPRINTF */
  339. #define printw printf
  340. #endif /* CKXPRINTF */
  341. #else                                   /* Use real curses */
  342. #ifdef CK_NCURSES                       /* or ncurses... */
  343. #ifdef CKXPRINTF                        /* Our printf macro conflicts with */
  344. #undef printf                           /* use of "printf" in ncurses.h */
  345. #endif /* CKXPRINTF */
  346. #include <ncurses.h>
  347. #ifdef CKXPRINTF
  348. #define printf ckxprintf
  349. #endif /* CKXPRINTF */
  350. #else  /* Not ncurses */
  351. #ifdef CKXPRINTF                        /* Our printf macro conflicts with */
  352. #undef printf                           /* use of "printf" in curses.h */
  353. #endif /* CKXPRINTF */
  354. #include <curses.h>
  355. #ifdef CKXPRINTF
  356. #define printf ckxprintf
  357. #endif /* CKXPRINTF */
  358. #endif /* CK_NCURSES */
  359. #endif /* MYCURSES */
  360. #endif /* VMS */
  362. #endif /* CK_CURSES */
  364. /*  F X D I N I T  --  File Xfer Display Initialization  */
  366. #ifdef CK_CURSES
  367. #ifndef MYCURSES
  368. #ifndef CK_SMG
  369. static
  370. #ifdef CK_ANSIC
  371. /* Can't use VOID because of curses.h */
  372. void
  373. ck_termset(int);
  374. #else
  375. ck_termset();
  376. #endif /* CK_ANSIC */
  377. #endif /* CK_SMG */
  378. #endif /* MYCURSES */
  379. #endif /* CK_CURSES */
  381. #ifdef NOTERMCAP
  382. static int notermcap = 1;
  383. #else
  384. static int notermcap = 0;
  385. #endif /* NOTERMCAP */
  387. #ifndef NODISPLAY
  388. #ifdef OSK
  389. VOID
  390. #else
  391. #ifdef CK_ANSIC
  392. void
  393. #endif /* CKANSIC */
  394. #endif /* OSK */
  395. fxdinit(xdispla) int xdispla; {
  396. #ifndef COHERENT
  397. #ifndef OS2
  398. #ifndef STRATUS
  399.     char *s;
  400.     int x, dummy;
  402.     debug(F101,"fxdinit xdispla","",xdispla);
  403.     debug(F101,"fxdinit fxd_inited","",fxd_inited);
  405. #ifdef IKSD
  406. #ifndef NOXFER
  407.     /* No curses for IKSD */
  408.     if (inserver) {
  409.         fdispla = XYFD_N;
  410.         return;
  411.     }
  412.     if (fxd_inited)                     /* Only do this once */
  413.       return;
  414. #endif /* NOXFER */
  415. #endif /* IKSD */
  417. #ifdef CK_CURSES
  418. #ifdef VMS
  419.     /* Force BRIEF in Batch logs */
  420.     if (batch && (xdispla == XYFD_C || xdispla == XYFD_S))
  421.       xdispla = XYFD_B;
  422. #else
  423.     if (xdispla == XYFD_C || xdispla == 9999) {
  425. #ifdef DYNAMIC
  426.         if (!trmbuf) {
  427. /*
  428.   Allocate tgetent() buffer.  Make it big -- some termcaps can be huge;
  429.   tgetent() merrily writes past the end of the buffer, causing core dumps
  430.   or worse.
  431. */
  432.             trmbuf = (char *)malloc(TRMBUFL);
  433.             if (!trmbuf) {
  434.                 notermcap = 1;
  435.                 debug(F101,"fxdinit malloc trmbuf","FAILED",TRMBUFL);
  436.                 fdispla = XYFD_S;
  437.                 return;
  438.             }
  439.             debug(F111,"fxdinit malloc trmbuf","OK",TRMBUFL);
  440.             debug(F001,"fxdinit trmbuf","",trmbuf);
  441. #ifdef COMMENT
  442.             memset(trmbuf,'',(size_t)TRMBUFL);
  443.             debug(F100,"fxdinit memset OK","",0);
  444. #endif /* COMMENT */
  445.         }
  446. #endif /* DYNAMIC */
  448.         debug(F100,"fxdinit before getenv(TERM)","",0);
  449.         s = getenv("TERM");
  450.         debug(F110,"fxdinit after getenv(TERM)",s,0);
  451.         if (!s) s = "";
  452.         if (*s) {
  453.             debug(F110,"fxdinit before tgetent()",s,0);
  454.             x = tgetent(trmbuf,s);
  455.             debug(F111,"fxdinit tgetent",s,x);
  456.         } else {
  457.             x = 0;
  458.             notermcap = 1;
  459.             debug(F110,"fxdinit TERM null - no tgetent",s,0);
  460.         }
  461.         if (x < 1 && !quiet && !backgrd
  462. #ifdef VMS
  463.             && !batch
  464. #endif /* VMS */
  465.             ) {
  466.             printf("Warning: terminal type unknown: "%s"n",s);
  467.             printf("SCREEN command will use ANSI sequences.n");
  468.             if (local)
  469.               printf("Fullscreen file transfer display disabled.n");
  470.             fdispla = XYFD_S;
  471.         }
  472. #ifndef MYCURSES
  473. #ifndef CK_SMG
  474.         ck_termset(x);
  475. #endif /* CK_SMG */
  476. #endif /* MYCURSES */
  477.         fxd_inited = 1;
  478.     }
  479. #endif /* CK_CURSES */
  480. #endif /* VMS */
  481. #endif /* STRATUS */
  482. #endif /* OS2 */
  483. #endif /* COHERENT */
  484. }
  485. #endif /* NODISPLAY */
  487. #ifdef CK_CURSES
  488. #ifdef CK_SMG
  489. /*
  490.   Long section for Screen Manager starts here...
  491.   By William Bader.
  492. */
  493. #include "ckvvms.h"
  494. #ifdef OLD_VMS
  495. #include <smgdef.h>                     /* use this on VAX C 2.4 */
  496. /* #include <smgmsg.h> */
  497. #else
  498. #include <smg$routines.h>               /* Martin Zinser */
  499. #endif /* OLD_VMS */
  501. extern unsigned int vms_status;     /* Used for system service return status */
  503. static long smg_pasteboard_id = -1;     /* pasteboard identifier */
  504. static long smg_display_id = -1;        /* display identifier */
  505. static int smg_open = 0;                /* flag if smg current open */
  506. static int smg_inited = 0;              /* flag if smg initialized */
  508. #ifdef COMMENT
  509. #define clrtoeol()      SMG$ERASE_LINE(&smg_display_id, 0, 0)
  511. #define clear()         SMG$ERASE_DISPLAY(&smg_display_id, 0, 0, 0, 0)
  513. #define touchwin(scr)   SMG$REPAINT_SCREEN(&smg_pasteboard_id)
  515. #else  /* Not COMMENT */
  517. #define clrtoeol()      smg$erase_line(&smg_display_id, 0, 0)
  519. #define clear()         smg$erase_display(&smg_display_id, 0, 0, 0, 0)
  521. #define touchwin(scr)   smg$repaint_screen(&smg_pasteboard_id)
  522. #endif /* COMMENT */
  524. #define clearok(curscr,ok)              /* Let wrefresh() do the work */
  526. #define wrefresh(cursrc) touchwin(scr)
  528. static void
  529. move(row, col) int row, col; {
  530.     /* Change from 0-based for curses to 1-based for SMG */
  531.     if (!smg_open)
  532.       return;
  533.     ++row; ++col;
  534.     debug(F111,"VMS smg move",ckitoa(row),col);
  535. #ifdef COMMENT                          /* Martin Zinser */
  536.     CHECK_ERR("move: smg$set_cursor_abs",
  537.               SMG$SET_CURSOR_ABS(&smg_display_id, &row, &col));
  538. #else
  539.     CHECK_ERR("move: smg$set_cursor_abs",
  540.               smg$set_cursor_abs(&smg_display_id, &row, &col));
  541. #endif /* COMMENT */
  542.     debug(F101,"VMS smg move vms_status","",vms_status);
  543. }
  545. #ifdef VMS_V40
  546. #define OLD_VMS
  547. #endif /* VMS_V40 */
  548. #ifdef VMS_V42
  549. #define OLD_VMS
  550. #endif /* VMS_V42 */
  551. #ifdef VMS_V44
  552. #define OLD_VMS
  553. #endif /* VMS_V44 */
  555. static int
  556. initscr() {
  557.     int rows = 24, cols = 80;
  558.     int row = 1, col = 1;
  560.     debug(F101,"VMS initscr smg_pasteboard_id A","",smg_pasteboard_id);
  562.     if (smg_pasteboard_id == -1) { /* Open the screen */
  563. #ifdef OLD_VMS                     /* Note: Routine calls lowercased 9/96 */
  564.         CHECK_ERR("initscr: smg$create_pasteboard",
  565.                   smg$create_pasteboard(&smg_pasteboard_id, 0, 0, 0, 0));
  566. #else
  567.         /* For VMS V5, not tested */
  568.         CHECK_ERR("initscr: smg$create_pasteboard",
  569.                   smg$create_pasteboard(&smg_pasteboard_id, 0, 0, 0, 0, 0));
  570. #endif /* OLD_VMS */
  571.     }
  572.     debug(F101,"VMS initscr smg_pasteboard_id B","",smg_pasteboard_id);
  573.     if (smg_pasteboard_id == -1) {
  574. printf("?Error initializing fullscreen displayn");
  575. fdispla = XYFD_S;
  576. dpyinit();
  577. return(0);
  578.     }
  579.     debug(F101,"VMS initscr smg_display_id","",smg_display_id);
  580.     if (smg_display_id == -1) {         /* Create a display window */
  582. #ifdef COMMENT                          /* Martin Zinser */
  583.         CHECK_ERR("initscr: smg$create_virtual_display",
  584.                   SMG$CREATE_VIRTUAL_DISPLAY(&rows, &cols, &smg_display_id,
  585.                                              0, 0, 0));
  587.         /* Connect the display window to the screen */
  588.         CHECK_ERR("initscr: smg$paste_virtual_display",
  589.                   SMG$PASTE_VIRTUAL_DISPLAY(&smg_display_id,&smg_pasteboard_id,
  590.                                             &row,&col));
  591. #else
  592.         CHECK_ERR("initscr: smg$create_virtual_display",
  593.                   smg$create_virtual_display(&rows, &cols, &smg_display_id,
  594.                                              0, 0, 0));
  596.         /* Connect the display window to the screen */
  597.         CHECK_ERR("initscr: smg$paste_virtual_display",
  598.                   smg$paste_virtual_display(&smg_display_id,&smg_pasteboard_id,
  599.                                             &row,&col));
  600. #endif /* COMMENT */
  601.     }
  602.     debug(F101,"VMS initscr smg_open A","",smg_open);
  603.     if (!smg_open) {                    /* Start a batch update */
  604.         smg_open = 1;
  605. #ifdef COMMENT
  606.         CHECK_ERR("initscr: smg$begin_pasteboard_update",
  607.                   SMG$BEGIN_PASTEBOARD_UPDATE(&smg_pasteboard_id));
  608. #else
  609.         CHECK_ERR("initscr: smg$begin_pasteboard_update",
  610.                   smg$begin_pasteboard_update(&smg_pasteboard_id));
  611. #endif /* COMMENT */
  612. debug(F101,"VMS initscr smg$begin_pasteboard_update","",vms_status);
  613.     }
  614.     debug(F101,"VMS initscr smg_open B","",smg_open);
  615.     smg_inited = 1;
  616.     return(1);
  617. }
  619. static void
  620. refresh() {
  621.     debug(F101,"refresh smg_pasteboard_id","",smg_pasteboard_id);
  623.     if (smg_open == 0 || smg_pasteboard_id == -1)
  624.       return;
  626. #ifdef COMMENT                          /* Martin Zinser */
  627.     CHECK_ERR("refresh: smg$end_pasteboard_update",
  628.               SMG$END_PASTEBOARD_UPDATE(&smg_pasteboard_id));
  629.     CHECK_ERR("refresh: smg$begin_pasteboard_update",
  630.               SMG$BEGIN_PASTEBOARD_UPDATE(&smg_pasteboard_id));
  631. #else
  632.     CHECK_ERR("refresh: smg$end_pasteboard_update",
  633.               smg$end_pasteboard_update(&smg_pasteboard_id));
  634.     CHECK_ERR("refresh: smg$begin_pasteboard_update",
  635.               smg$begin_pasteboard_update(&smg_pasteboard_id));
  636. #endif /* COMMENT */
  637. }
  639. static void
  640. endwin() {
  641.     if (!smg_open)
  642.       return;
  644.     smg_open = 0;
  646. #ifdef COMMENT
  647.     CHECK_ERR("endwin: smg$end_pasteboard_update",
  648.               SMG$END_PASTEBOARD_UPDATE(&smg_pasteboard_id));
  649. #else
  650.     CHECK_ERR("endwin: smg$end_pasteboard_update",
  651.               smg$end_pasteboard_update(&smg_pasteboard_id));
  652. #endif /* COMMENT */
  654.     move(22, 0);
  656. #ifdef COMMENT
  657. /*
  658.   These calls clear the screen.
  659.   (convert routine calls to lowercase - Martin Zinser)
  660. */
  661.     CHECK_ERR("endwin: smg$delete_virtual_display",
  662.               SMG$DELETE_VIRTUAL_DISPLAY(&smg_display_id));
  663.     smg_display_id = -1;
  665.     CHECK_ERR("endwin: smg$delete_pasteboard",
  666.               SMG$DELETE_PASTEBOARD(&smg_pasteboard_id, 0));
  667.     smg_pasteboard_id = -1;
  668. #endif /* COMMENT */
  669. }
  671. #ifdef COMMENT
  672. /* DECC 6.2 screams bloody murder about printw ("not enough args") */
  673. /* but adding the following prototype only makes it holler louder. */
  674. #ifdef __DECC
  675. /* "varargs" prototype for printw */
  676. _PROTOTYP(static int printw,(char *, ...));
  677. #endif /* __DECC */
  678. #endif /* COMMENT */
  680. #ifdef __DECC
  681. #include <stdarg.h>
  682. _PROTOTYP(static void printw,(char *, ...));
  683. static void
  684. printw(char *str,...) {
  685.     char buf[255];
  686.     va_list ap;
  687.     $DESCRIPTOR(text_dsc, 0);
  688.     text_dsc.dsc$a_pointer=buf;
  689.     if (!smg_open)
  690.       return;
  691.     va_start(ap,str);
  692.     text_dsc.dsc$w_length = vsprintf(buf, str, ap);
  693.     va_end(ap);
  694.     CHECK_ERR("printw: smg$put_chars",
  695.               smg$put_chars(&smg_display_id, &text_dsc, 0, 0, 0, 0, 0));
  696. }
  697. #else
  698. static void
  699. printw(str, a1, a2, a3, a4, a5, a6, a7, a8)
  700.     char *str;
  701.     long a1, a2, a3, a4, a5, a6, a7, a8;
  702. /* printw */ {
  703.     char buf[255];
  704.     $DESCRIPTOR(text_dsc, 0);
  705.     if (!smg_open)
  706.       return;
  707.     text_dsc.dsc$a_pointer=buf;
  708.     text_dsc.dsc$w_length = sprintf(buf, str, a1, a2, a3, a4, a5, a6, a7, a8);
  709.     CHECK_ERR("printw: smg$put_chars",
  710.               smg$put_chars(&smg_display_id, &text_dsc, 0, 0, 0, 0, 0));
  711. }
  712. #endif /* __DECC */
  714. #define CK_CURPOS
  715. int
  716. ck_curpos(row, col) {
  717.     debug(F111,"VMS smg ck_curpos",ckitoa(row),col);
  718.     if (!smg_inited || !smg_open) {
  719.         initscr();
  720.     }
  721.     debug(F101,"VMS smg curpos smg_open","",smg_open);
  722.     if (!smg_open)
  723.       return(0);
  724.     debug(F111,"VMS smg ck_curpos",ckitoa(row-1),col-1);
  725.     move(row - 1, col - 1);             /* SMG is 0-based */
  726.     refresh();
  727.     /* endwin(); */
  728.     return(0);
  729. }
  731. int
  732. ck_cls() {
  733.     debug(F101,"VMS smg ck_cls smg_inited","",smg_inited);
  734.     if (!smg_inited || !smg_open) {
  735.         initscr();
  736.     }
  737.     debug(F101,"VMS smg ck_cls smg_open","",smg_open);
  738.     if (!smg_open)
  739.       return(0);
  740.     clear();
  741.     refresh();
  742.     /* endwin(); */
  743.     return(0);
  744. }
  746. int
  747. ck_cleol() {
  748.     debug(F101,"VMS smg ck_cleol smg_inited","",smg_inited);
  749.     if (!smg_inited || !smg_open) {
  750.         initscr();
  751.     }
  752.     debug(F101,"VMS smg ck_cleol smg_open","",smg_open);
  753.     if (!smg_open)
  754.       return(0);
  755.     clrtoeol();
  756.     refresh();
  757.     /* endwin(); */
  758.     return(0);
  759. }
  760. #endif /* CK_SMG */
  762. #ifdef MYCURSES
  763. /*
  764.   Do-it-yourself curses implementation for VMS, OS/2 and other ANSI/VT-100's.
  765.   Supports only the VT52 and VT1xx (and later VT2xx/3xx/4xx) terminals.
  766.   By Terry Kennedy, St Peters College.
  768.   First, some stuff we can just ignore:
  769. */
  771. static int
  772. touchwin(x) int x; {
  773.     return(0);
  774. }
  775. static int
  776. initscr() {
  777.     return(0);
  778. }
  779. static int
  780. refresh() {
  781.     return(0);
  782. }
  783. static int
  784. endwin() {
  785.     return(0);
  786. }
  788. /*
  789.  * Now, some stuff we need to do:
  790.  */
  792. _PROTOTYP( int move, (int, int) );
  793. #ifndef OS2
  794. int
  795. move(row, col) int row, col; {
  796.     if (isvt52)
  797.       printf("33Y%c%c", row + 037, col + 037);
  798.     else
  799.       printf("33[%d;%dH", row + 1, col + 1);
  800.     return(0);
  801. }
  803. int
  804. clear() {
  805.     move(0,0);
  806.     if (isvt52)
  807.       printf("33J");
  808.     else
  809.       printf("33[J");
  810.     return(0);
  811. }
  813. int
  814. clrtoeol() {
  815.     if (isvt52)
  816.       printf("33K");
  817.     else
  818.       printf("33[K");
  819.     return(0);
  820. }
  822. #define CK_CURPOS
  823. int
  824. ck_cls() {
  825.     return(clear());
  826. }
  828. int
  829. ck_cleol() {
  830.     return(clrtoeol());
  831. }
  833. int
  834. ck_curpos(row, col) int row, col; {
  835.     move(row, col);
  836.     return(0);
  837. }
  839. #else /* OS2 */
  840. /* Windows NT and Windows 95 do not provide ANSI emulation */
  841. /* Therefore we might as well not use it for OS/2 either   */
  843. int
  844. move(row, col) int row, col; {
  845. #ifndef ONETERMUPD
  846.     SetCurPos(row, col);
  847. #endif /* ONETERMUPD */
  848.     lgotoxy( VCMD, col+1, row+1);
  849.     VscrnIsDirty(VCMD);
  850.     return(0);
  851. }
  853. int
  854. clear() {
  855.     viocell cell;
  856.     move(0,0);
  857. #ifdef ONETERMUPD
  858.     if (VscrnGetBufferSize(VCMD) > 0) {
  859.         VscrnScroll(VCMD, UPWARD, 0,
  860.                     VscrnGetHeight(VCMD)-(1),
  861.                     VscrnGetHeight(VCMD)-(0), TRUE, CHR_SP);
  862.         cleartermscreen(VCMD);
  863.     }
  864. #else
  865.     cell.c = ' ';
  866.     cell.a = colorcmd;
  867.     WrtNCell(cell, cmd_rows * cmd_cols, 0, 0);
  868. #endif /* ONETERMUPD */
  869.     return(0);
  870. }
  872. int
  873. clrtoeol() {
  874.     USHORT row, col;
  875.     viocell cell;
  877.     cell.c = ' ';
  878.     cell.a = colorcmd;
  879. #ifndef ONETERMUPD
  880.     GetCurPos(&row, &col );
  881.     WrtNCell(cell, cmd_cols - col -1, row, col);
  882. #endif /* ONETERMUPD */
  883.     clrtoeoln(VCMD,CHR_SP);
  884.     return(0);
  885. }
  887. #define CK_CURPOS
  888. int
  889. ck_curpos(row, col) int row, col; {
  890.     move(row, col);
  891.     return(0);
  892. }
  894. int
  895. ck_cls() {
  896.     return(clear());
  897. }
  899. int
  900. ck_cleol() {
  901.     return(clrtoeol());
  902. }
  904. #endif /* OS2 */
  905. #endif /* MYCURSES */
  907. #ifndef NOTERMCAP
  908. #ifndef CK_CURPOS
  909. #define CK_CURPOS
  911. /* Termcap/Terminfo section */
  913. static char cur_cls[32] = { NUL, NUL };
  914. static char cur_cleol[32] = { NUL, NUL };
  915. static char cur_cm[64] = { NUL, NUL };
  916. static char tgsbuf[128] = { NUL, NUL };
  918. static
  919. #ifdef CK_ANSIC
  920. void
  921. #endif /* CK_ANSIC */
  922. ck_termset(x) int x; {
  923.     cur_cls[0] = NUL;
  924.     cur_cleol[0] = NUL;
  925.     cur_cm[0] = NUL;
  926. #ifdef tgetent
  927.     debug(F100,"tgetent is a macro","",0);
  928. #endif /* tgetent */
  929. #ifdef tgetstr
  930.     debug(F100,"tgetstr is a macro","",0);
  931. #endif /* tgetstr */
  932. #ifdef tputs
  933.     debug(F100,"tputs is a macro","",0);
  934. #endif /* tputs */
  935. #ifdef tgoto
  936.     debug(F100,"tgoto is a macro","",0);
  937. #endif /* tgoto */
  938. #ifdef NOTERMCAP
  939.     /* tgetstr() gets a segmentation fault on OSF/1 */
  940.     debug(F100,"ck_termset NOTERMCAP","",0);
  941. #else
  942.     if (notermcap) {
  943.         debug(F100,"ck_termset notermcap","",0);
  944.         return;
  945.     }
  946.     debug(F101,"ck_termset x","",x);
  947.     if (x > 0) {
  948.         char * bp;
  949.         bp = tgsbuf;
  950.         *bp = NUL;
  951.         debug(F110,"ck_termset calling tgetstr","cl",0);
  952.         if (tgetstr("cl", &bp)) {       /* Get clear-screen code */
  953.             debug(F110,"ck_termset tgetstr cl",tgsbuf,"");
  954.             if ((int)strlen(tgsbuf) < 32)
  955.               strcpy(cur_cls,tgsbuf);
  956.         } else
  957.           return;
  958.         bp = tgsbuf;
  959.         if (tgetstr("ce", &bp)) {       /* Get clear-to-end-of-line code */
  960.             debug(F110,"ck_termset tgetstr ce",tgsbuf,"");
  961.             if ((int)strlen(tgsbuf) < 32)
  962.               strcpy(cur_cleol,tgsbuf);
  963.         } else
  964.           return;
  965.         bp = tgsbuf;
  966.         if (tgetstr("cm", &bp)) {       /* Get cursor-movement code */
  967.             debug(F110,"ck_termset tgetstr cm",tgsbuf,"");
  968.             if ((int)strlen(tgsbuf) < 64)
  969.               strcpy(cur_cm,tgsbuf);
  970.         } else
  971.           return;
  972.     }
  973. #endif /* NOTERMCAP */
  974. }
  976. #ifndef TPUTSFNTYPE
  977. #ifdef TPUTSISVOID
  978. #define TPUTSFNTYPE void
  979. #else
  980. #define TPUTSFNTYPE int
  981. #endif /* TPUTSISVOID */
  982. #endif /* TPUTSFNTYPE */
  984. #ifndef TPUTSARGTYPE
  985. #ifdef HPUX9
  986. #define TPUTSARGTYPE char
  987. #else
  988. #ifdef HPUX10
  989. #define TPUTSARGTYPE char
  990. #else
  991. #define TPUTSARGTYPE int
  992. #endif /* HPUX10 */
  993. #endif /* HPUX9 */
  994. #endif /* TPUTSARGTYPE */
  996. static TPUTSFNTYPE
  997. #ifdef CK_ANSIC
  998. ck_outc(TPUTSARGTYPE x)
  999. #else
  1000. ck_outc(x) TPUTSARGTYPE x;
  1001. #endif /* CK_ANSIC */
  1002. {                                       /* To satisfy tputs() arg3 prototype */
  1003.     int rc;
  1004.     char c;
  1005.     c = (char) x;
  1006.     rc = (inserver) ? ttoc(c) : conoc(c);
  1007. #ifndef TPUTSISVOID
  1008.     return(rc);
  1009. #endif /* TPUTSISVOID */
  1010. }
  1012. int
  1013. ck_curpos(row, col) {
  1014. #ifdef CK_ANSIC
  1015.     TPUTSFNTYPE (*fn)(TPUTSARGTYPE);
  1016. #else
  1017.     TPUTSFNTYPE (*fn)();
  1018. #endif /* CK_ANSIC */
  1019.     if (!fxd_inited)
  1020.       fxdinit(9999);
  1021.     if (!cur_cm[0]) {                   /* We don't have escape sequences */
  1022. #ifdef COMMENT
  1023.         return(-1);                     /* Do nothing */
  1024. #else
  1025.         /* Both C-Kermit's SCREEN command and ANSI/VT100 are 1-based */
  1026.         printf("33[%d;%dH", row, col); /* Or default to ANSI */
  1027. #endif /* COMMENT */
  1028.     } else {
  1029.         fn = ck_outc;
  1030.         /* termcap/terminfo is 0-based */
  1031.         tputs(
  1032. #ifdef TPUTSARG1CONST
  1033.               (const char *)
  1034. #endif /* TPUTSARG1CONST */
  1035.               tgoto(cur_cm,col-1,row-1),1,fn);
  1036.     }
  1037.     return(0);
  1038. }
  1040. int
  1041. ck_cls() {
  1042. #ifdef CK_ANSIC
  1043.     TPUTSFNTYPE (*fn)(TPUTSARGTYPE);
  1044. #else
  1045.     TPUTSFNTYPE (*fn)();
  1046. #endif /* CK_ANSIC */
  1047.     if (!fxd_inited)
  1048.       fxdinit(9999);
  1049.     if (!cur_cls[0]) {                  /* If we don't have escape sequences */
  1050. #ifdef COMMENT
  1051.         return(-1);                     /* Do nothing */
  1052. #else
  1053.         printf("33[;H33[2J");       /* Or default to ANSI */
  1054. #endif /* COMMENT */
  1055.     } else {
  1056.         fn = ck_outc;
  1057.         debug(F111,"ck_cls 2",cur_cls,fxd_inited);
  1058.         tputs(cur_cls,cmd_rows,fn);
  1059.     }
  1060.     return(0);
  1061. }
  1063. int
  1064. ck_cleol() {
  1065. #ifdef CK_ANSIC
  1066.     TPUTSFNTYPE (*fn)(TPUTSARGTYPE);
  1067. #else
  1068.     TPUTSFNTYPE (*fn)();
  1069. #endif /* CK_ANSIC */
  1070.     if (!fxd_inited)
  1071.       fxdinit(9999);
  1072.     if (!cur_cleol[0]) {                /* If we don't have escape sequences */
  1073. #ifdef COMMENT
  1074.         return(-1);                     /* Do nothing */
  1075. #else
  1076.         printf("33[K");               /* Or use ANSI */
  1077. #endif /* COMMENT */
  1078.     } else {
  1079.         fn = ck_outc;
  1080.         tputs(cur_cleol,1,fn);
  1081.     }
  1082.     return(0);
  1083. }
  1084. #endif /* CK_CURPOS */
  1085. #else
  1086. static void
  1087. ck_termset(x) int x; {
  1088.     if (x) return;
  1089. }
  1090. #endif /* NOTERMCAP */
  1092. #ifndef CK_CURPOS
  1093. #define CK_CURPOS
  1094. int
  1095. ck_cls() {
  1096.     printf("33[;H33[2J");
  1097.     return(0);
  1098. }
  1100. int
  1101. ck_cleol() {
  1102.     printf("33[K");
  1103.     return(0);
  1104. }
  1106. int
  1107. ck_curpos(row, col) int row, col; {
  1108.     printf("33[%d;%dH", row, col);
  1109.     return(0);
  1110. }
  1111. #endif /* CK_CURPOS */
  1114. static int cinit = 0;                   /* Flag for curses init'd */
  1115. static int cendw = 0;                   /* endwin() was called */
  1117. static
  1118. #ifdef CK_ANSIC                         /* Because VOID used by curses.h */
  1119. void
  1120. #else
  1121. #ifdef MYCURSES
  1122. VOID
  1123. #else
  1124. int
  1125. #endif /* MYCURSES */
  1126. #endif /* CK_ANSIC */
  1128. #ifdef CK_ANSIC                         /* Update % transfered and % bar */
  1129. updpct(long old, long new)
  1130. #else /* CK_ANSIC */
  1131. updpct(old, new) long old, new;
  1132. #endif /* CK_ANSIC */
  1133. /* updpct */ {
  1134. #ifdef COMMENT
  1135.     int m, n;
  1136.     move(CW_PCD,22);
  1137.     printw("%ld", new);
  1138. #ifdef KUI
  1139. #ifndef K95G
  1140.     KuiSetProperty(KUI_FILE_TRANSFER, (long) CW_PCD, (long) new);
  1141. #endif /* K95G */
  1142. #endif /* KUI */
  1143. #ifdef CK_PCT_BAR
  1144.     if (thermometer) {
  1145.         if (old > new) {
  1146.             old = 0;
  1147.             move(CW_PCD, 26);
  1148.             clrtoeol();
  1149.         }
  1150.         m = old/2;
  1151.         move(CW_PCD, 26 + m);
  1152.         n = new / 2 - m;
  1153. #ifndef OS2
  1154.         while (n > 0) {
  1155.             if ((m + 1) % 5 == 0)
  1156.               printw("*");
  1157.             else
  1158.               printw("=");
  1159.             m++;
  1160.             n--;
  1161.         }
  1162.         if (new % 2 != 0) printw("-");
  1163.         /* move(CW_PCD, 22+53); */
  1164. #else /* OS2 */
  1165.         while (n > 0) {
  1166.             printw("%c", '333');
  1167.             m++; n--;
  1168.         }
  1169.         if (new % 2 != 0)
  1170.           printw("%c", '261');
  1171. #endif /* OS2 */
  1172.     }
  1173. #endif /* CK_PCT_BAR */
  1174.     /* clrtoeol(); */
  1175. #else  /* !COMMENT */
  1176. #ifdef OS2
  1177. #define CHAR1   '333'          /* OS2 */
  1178. #define CHAR2   '261'
  1179. #else
  1180. #define CHAR1   '/'             /* Default */
  1181. #define CHAR2   '-'
  1182. #endif /* OS2 */
  1183.     debug(F101,"updpct old","",old);
  1184.     debug(F101,"updpct new","",new);
  1185.     move(CW_PCD,22);
  1186.     printw("%-3ld", new); /*  (was)   printw("%ld", new);  */
  1187. #ifdef KUI
  1188. #ifndef K95G
  1189.     KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_PCD, (long) new );
  1190. #endif /* K95G */
  1191. #endif /* KUI */
  1192. #ifdef CK_PCT_BAR
  1193.     if (thermometer) {
  1194.         int m, n;
  1196.         if (old > new) {
  1197.             old = 0 ;
  1198.             move(CW_PCD, 26);
  1199.             clrtoeol();
  1200.         }
  1201.         if (new <= 100L) {
  1202.             m = old / 2;
  1203.             n = new / 2 - m;
  1204.             move(CW_PCD, 26+m);
  1205.             while (n-- > 0)
  1206.               printw("%c", CHAR1);
  1207.             if (new % 2 != 0)
  1208.               printw("%c", CHAR2);
  1209.         }
  1210.     }
  1211. #endif /* CK_PCT_BAR */
  1212. #endif /* COMMENT */
  1213. }
  1215. static long old_tr = -1L;               /* Time remaining previously */
  1217. static long
  1218. #ifdef CK_ANSIC
  1219. shoetl(long old_tr, long cps, long fsiz, long howfar)
  1220. #else
  1221. shoetl(old_tr, cps, fsiz, howfar) long old_tr, cps, fsiz, howfar;
  1222. #endif /* CK_ANSIC */
  1223. /* shoetl */ {                          /* Estimated time left in transfer */
  1224.     long tr;                            /* Time remaining, seconds */
  1226. #ifdef GFTIMER
  1227.     if (fsiz > 0L && cps > 0L)
  1228.       tr = (long)((CKFLOAT)(fsiz - howfar) / (CKFLOAT)cps);
  1229.     else
  1230.       tr = -1L;
  1231. #else
  1232.     tr = (fsiz > 0L && cps > 0L) ?
  1233.       ((fsiz - howfar) / cps) :
  1234.         -1L;
  1235. #endif /* GFTIMER */
  1236.     debug(F101,"SUNDAY tr","",tr);
  1237.     debug(F101,"SUNDAY old_tr","",old_tr);
  1238.     move(CW_TR,22);
  1239.     if (tr > -1L) {
  1240.         if (tr != old_tr) {
  1241.             printw("%s",hhmmss(tr));
  1242. #ifdef KUI
  1243. #ifndef K95G
  1244.             KuiSetProperty(KUI_FILE_TRANSFER, (long)CW_TR, (long)hhmmss(tr));
  1245. #endif /* K95G */
  1246. #endif /* KUI */
  1247.             clrtoeol();
  1248.         }
  1249.     } else {
  1250.         printw("(unknown)");
  1251. #ifdef KUI
  1252. #ifndef K95G
  1253.         KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_TR, (long) "(unknown)" );
  1254. #endif /* K95G */
  1255. #endif /* KUI */
  1256.         clrtoeol();
  1257.     }
  1258.     return(tr);
  1259. }
  1261. static long
  1262. #ifdef CK_ANSIC
  1263. shocps(int pct, long fsiz, long howfar)
  1264. #else
  1265. shocps(pct, fsiz, howfar) int pct; long fsiz, howfar;
  1266. #endif /* CK_ANSIC */
  1267. /* shocps */ {
  1268.     static long oldffc = 0L;
  1269. #ifdef GFTIMER
  1270.     CKFLOAT secs, xx;
  1271. #else
  1272.     long secs, xx;
  1273. #endif /* GFTIMER */
  1275. #ifdef GFTIMER
  1276.     xx = (gtv >= 0.0) ? gtv : 0.0;      /* Floating-point version */
  1277.     gtv = gftimer();
  1278.     if ((gtv - oldgtv) < (CKFLOAT) 1.0) /* Only do this once per second */
  1279.       return(oldcps);
  1280.     oldgtv = xx;
  1281. #else
  1282.     xx = (gtv >= 0) ? gtv : 0;          /* Whole-number version */
  1283.     gtv = gtimer();
  1284.     if ((gtv - oldgtv) < 1)
  1285.       return(oldcps);
  1286.     oldgtv = xx;
  1287. #endif /* GFTIMER */
  1289. #ifdef CPS_WEIGHTED
  1290.     debug(F100,"SHOCPS: WEIGHTED","",0);
  1291.     if (gtv != oldgtv) {                /* The first packet is ignored */
  1292.         if (ffc < oldffc)
  1293.           oldffc = ffc;
  1294.         oldcps = cps;
  1295.         if (oldcps && oldgtv >
  1296. #ifdef GFTIMER
  1297.             1.0
  1298. #else
  1299.             1
  1300. #endif /* GFTIMER */
  1301.             ) {                         /* The first second is ignored */
  1302. /*
  1303.   This version of shocps() produces a weighted average that some
  1304.   people like, but most people find it disconcerting and bombard us
  1305.   with questions and complaints about why the CPS figure fluctuates so
  1306.   wildly.  So now you only get the weighted average if you build the
  1307.   program yourself with CPS_WEIGHTED defined.
  1308. */
  1309. #ifndef CPS_VINCE
  1310. #ifdef GFTIMER
  1311.             cps = (long)((((CKFLOAT)oldcps * 3.0) +
  1312.                    (CKFLOAT)(ffc - oldffc) / (gtv-oldgtv) ) / 4.0);
  1313. #else
  1314.             cps = ( (oldcps * 3) + (ffc - oldffc) / (gtv-oldgtv) ) / 4;
  1315. #endif /* GFTIMER */
  1316. #else
  1317. /* And an alternate weighting scheme from Vincent Fatica... */
  1318.             cps = (3 *
  1319.              ((1+pct/300)*oldffc/oldgtv+(1-pct/100)*(ffc-oldffc)/(gtv-oldgtv)))
  1320.               / 4;
  1321. #endif /* CPS_VINCE */
  1322.         } else {
  1323.             /* No weighted average since there is nothing to weigh */
  1324. #ifdef GFTIMER
  1325.             cps = (long)(gtv != 0.0 ?
  1326.               (CKFLOAT)(ffc - oldffc) / (gtv - oldgtv) :
  1327.                 (ffc - oldffc)) ;
  1328. #else
  1329.             cps = gtv ? (ffc - oldffc) / (gtv - oldgtv) : (ffc - oldffc) ;
  1330. #endif /* GFTIMER */
  1331.         }
  1332. #ifdef DEBUG
  1333.         if (deblog) {
  1334.             debug(F101,"SHOCPS: pct   ","",pct);
  1335.             debug(F101,"SHOCPS: gtv   ","",gtv);
  1336.             debug(F101,"SHOCPS: oldgtv","",oldgtv);
  1337.             debug(F101,"SHOCPS: dgtv  ","",(long)(gtv-oldgtv));
  1338.             debug(F101,"SHOCPS: ffc   ","",ffc);
  1339.             debug(F101,"SHOCPS: oldffc","",oldffc);
  1340.             debug(F101,"SHOCPS: dffc  ","",ffc-oldffc);
  1341.             debug(F101,"SHOCPS: cps   ","",cps);
  1342.         }
  1343. #endif /* DEBUG */
  1344.         move(CW_CP,22);
  1345.         printw("%ld", cps);
  1346. #ifdef KUI
  1347. #ifndef K95G
  1348.         KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_CP, (long) cps );
  1349. #endif /* K95G */
  1350. #endif /* KUI */
  1351.         clrtoeol();
  1352.         oldffc = ffc;
  1353.     }
  1354. #else /* !CPS_WEIGHTED */
  1355. #ifdef DEBUG
  1356.     debug(F100,"SHOCPS: NOT WEIGHTED","",0);
  1357.     if (deblog) {
  1358.         debug(F101,"SHOCPS: pct    ","",pct);
  1359.         debug(F101,"SHOCPS: gtv    ","",gtv);
  1360.         debug(F101,"SHOCPS: oldgtv ","",oldgtv);
  1361.         debug(F101,"SHOCPS: dgtv   ","",(long)gtv - (long)oldgtv);
  1362.         debug(F101,"SHOCPS: ffc    ","",ffc);
  1363.         debug(F101,"SHOCPS: oldffc ","",oldffc);
  1364.         debug(F101,"SHOCPS: dffc   ","",ffc-oldffc);
  1365.         debug(F101,"SHOCPS: cps    ","",cps);
  1366.         debug(F101,"SHOCPS: filcnt ","",filcnt);
  1367. #ifdef GFTIMER
  1368.         debug(F101,"SHOCPS: fpfsecs","",fpfsecs);
  1369. #endif /* GFTIMER */
  1370.     }
  1371.     debug(F101,"shocps gtv","",gtv);
  1372. #endif /* DEBUG */
  1373. #ifdef GFTIMER
  1374.     debug(F101,"shocps fpfsecs","",fpfsecs);
  1375.     secs = gtv - fpfsecs;
  1376.     debug(F101,"shocps secs","",(long)secs);
  1377.     if (secs > 0.0) {
  1378.         cps = (long)((CKFLOAT) ffc / secs);
  1379.         debug(F101,"shocps cps","",cps);
  1380.         move(CW_CP,22);
  1381. #ifdef KUI
  1382. #ifndef K95G
  1383.         KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_CP, (long) cps );
  1384. #endif /* K95G */
  1385. #endif /* KUI */
  1386.         printw("%ld", cps);
  1387.         clrtoeol();
  1388.     }
  1389. #else  /* Not GFTIMER */
  1390.     if ((secs = gtv - fsecs) > 0) {
  1391.         cps = (secs < 1L) ? ffc : ffc / secs;
  1392.         move(CW_CP,22);
  1393. #ifdef KUI
  1394. #ifndef K95G
  1395.         KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_CP, (long) cps );
  1396. #endif /* K95G */
  1397. #endif /* KUI */
  1398.         printw("%ld", cps);
  1399.         clrtoeol();
  1400.     }
  1401. #endif /* GFTIMER */
  1402. #endif /* CPS_WEIGHTED */
  1404.     if (cps > peakcps &&                /* Peak transfer rate */
  1405.         ((what == W_SEND && spackets > wslots + 4) ||
  1406.         (what != W_SEND && spackets > 10))) {
  1407.         peakcps = cps;
  1408.     }
  1409.     old_tr = shoetl(old_tr, cps, fsiz, howfar);
  1410.     return(cps);
  1411. }
  1413. static
  1414. #ifdef CK_ANSIC                         /* Because VOID used by curses.h */
  1415. void
  1416. #else
  1417. #ifdef MYCURSES
  1418. VOID
  1419. #else
  1420. int
  1421. #endif /* MYCURSES */
  1422. #endif /* CK_ANSIC */
  1423. scrft() {                               /* Display file type */
  1424.     char xferstr[80];
  1425.     xferstr[0] = NUL;
  1426.     if (binary) {
  1427.         switch(binary) {
  1428.           case XYFT_L:
  1429.             strcpy( xferstr, "LABELED" ) ;
  1430.             break;
  1431.           case XYFT_I:
  1432.             strcpy( xferstr, "IMAGE" );
  1433.             break;
  1434.           case XYFT_U:
  1435.             strcpy( xferstr, "BINARY UNDEFINED" );
  1436.             break;
  1437.           default:
  1438.           case XYFT_B:
  1439.             strcpy( xferstr, "BINARY" );
  1440.             break;
  1441.         }
  1442. #ifdef CK_RESEND
  1443.         if (what == W_SEND && sendstart > 0L) {
  1444.             if (sendmode == SM_PSEND) {
  1445.                 strcat( xferstr, " / partial");
  1446.             } else if (sendmode == SM_RESEND) {
  1447.                 strcat( xferstr, " / resend");
  1448.             }
  1449.         } else if (what == W_RECV && rs_len > 0L) {
  1450.             strcat( xferstr, " / resend");
  1451.         }
  1452. #endif /* CK_RESEND */
  1453.     } else {
  1454.         strcpy(xferstr, "TEXT") ;
  1455. #ifndef NOCSETS
  1456.         if (tcharset == TC_TRANSP) {
  1457.             strcat( xferstr, " (no translation)");
  1458.         } else {
  1459.             if (what == W_SEND) {
  1460.                 sprintf( &xferstr[strlen(xferstr)],
  1461.                         " (%s => %s)",
  1462.                         fcsinfo[fcharset].keyword,
  1463.                         tcsinfo[tcharset].keyword);
  1464.             } else {
  1465.                 sprintf( &xferstr[strlen(xferstr)],
  1466.                         " (%s => %s)",
  1467.                         tcsinfo[tcharset].keyword,
  1468.                         fcsinfo[fcharset].keyword);
  1469.             }
  1470.         }
  1471. #endif /* NOCSETS */
  1472.     }
  1473.     move(CW_TYP,22);
  1474.     printw("%s", xferstr);
  1475.     clrtoeol();
  1476. #ifdef KUI
  1477. #ifndef K95G
  1478.     KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_TYP, (long) xferstr );
  1479. #endif /* K95G */
  1480. #endif /* KUI */
  1481.     return;
  1482. }
  1484. #ifdef CK_NEWTERM
  1485. static FILE *ck_stdout = NULL;
  1486. static int ck_fd = -1;
  1487. #endif /* CK_NEWTERM */
  1489. static long pct = 0L, oldpct = 0L, oldrtt = -1L;
  1490. static int oldtyp = 0, oldwin = -1, oldtry = -1, oldlen = -1, oldtim = -1;
  1492. #ifdef NETCONN
  1493. static char *netname[] = {
  1494.     "none", "TCP/IP", "TCP/IP", "X.25", "DECnet", "VAX PSI", "Named Pipes",
  1495.     "X.25", "NetBIOS", "SuperLAT", "File", "Command", "DLL", "SSH",
  1496.     "X.25", "X.25", NULL
  1497. };
  1498. #endif /* NETCONN */
  1500. #ifdef CK_ANSIC
  1501. void
  1502. screenc(int f, char c,long n,char *s)
  1503. #else
  1504. #ifdef MYCURSES
  1505. VOID
  1506. #else
  1507. int
  1508. #endif /* MYCURSES */
  1509. screenc(f,c,n,s)
  1510. int f;          /* argument descriptor */
  1511. char c;         /* a character or small integer */
  1512. long n;         /* a long integer */
  1513. char *s;        /* a string */
  1514. #endif /* CK_ANSIC */
  1515. /* screenc() */ {
  1516. #ifdef CK_SSL
  1517.     extern int tls_active_flag, ssl_active_flag;
  1518. #endif /* CK_SSL */
  1519. #ifdef RLOGCODE
  1520.     extern int ttnproto;
  1521. #endif /* RLOGCODE */
  1523.     static int q = 0;
  1524.     static long fsiz = -1L;   /* Copy of file size */
  1525.     static long fcnt = 0L;    /* Number of files transferred */
  1526.     static long fbyt = 0L;    /* Total file bytes of all files transferred */
  1527.     static long howfar = 0L;  /* How much of current file has been xfer'd. */
  1528.     static int  pctlbl = 0L;  /* Percent done vs Bytes so far */
  1529.     long cps = 0L;
  1531.     int len;                            /* Length of string */
  1532.     int errors = 0;                     /* Error counter */
  1533.     int x;                              /* Worker */
  1535.     debug(F101,"screenc cinit","",cinit);
  1536.     debug(F101,"screenc cendw","",cendw);
  1538.     if (!s) s = "";                     /* Always do this. */
  1540.     if (cinit == 0 || cendw > 0) {      /* Handle borderline cases... */
  1541.         if (f == SCR_CW) {              /* Close window, but it's not open */
  1542.             ft_win = 0;
  1543.             return;
  1544.         }
  1545.         debug(F111,"screenc fatal A",s,f);
  1546.         if (f == SCR_EM ||
  1547.            (f == SCR_PT && c == 'E')) { /* Fatal error before window open */
  1548.             conoll(""); conoc('?'); conoll(s); return; /* Regular display */
  1549.         }
  1550.     }
  1551.     if (cinit == 0) {                   /* Only call initscr() once */
  1552.         cendw = 1;                      /* New window needs repainting */
  1553. #ifdef COMMENT
  1554.         if (!initscr()) {               /* Oops, can't initialize window? */
  1555. /*
  1556.   In fact, this doesn't happen.  "man curses" says initscr() halts the
  1557.   entire program if it fails, which is true on the systems where I've
  1558.   tested it.  It will fail if your terminal type is not known to it.
  1559.   That's why SET FILE DISPLAY FULLSCREEN calls tgetent() to make sure the
  1560.   terminal type is known before allowing a curses display.
  1561. */
  1562.             fprintf(stderr,"CURSES INITSCR ERRORrn");
  1563.             fdispla = XYFD_S;           /* Fall back to CRT display */
  1564.             return;
  1565.         } else {
  1566.             cinit++;                    /* Window initialized ok */
  1567.             debug(F100,"CURSES INITSCR OK","",0);
  1568.         }
  1569. #else                                   /* Save some memory. */
  1570. #ifdef CK_NEWTERM
  1571.         /* (From Andy Fyfe <andy@vlsi.cs.caltech.edu>)
  1572.            System V curses seems to reserve the right to alter the buffering
  1573.            on the output FILE* without restoring it.  Fortunately System V
  1574.            curses provides newterm(), an alternative to initscr(), that
  1575.            allows us to specify explicitly the terminal type and input and
  1576.            output FILE pointers.  Thus we duplicate stdout, and let curses
  1577.            have the copy.  The original remains unaltered.  Unfortunately,
  1578.            newterm() seems to be particular to System V.
  1579.         */
  1580.         s = getenv("TERM");
  1581.         if (ck_fd < 0) {
  1582.             ck_fd = dup(fileno(stdout));
  1583.             ck_stdout = (ck_fd >= 0) ? fdopen(ck_fd, "w") : NULL;
  1584.         }
  1585.         debug(F100,"screenc newterm...","",0);
  1586.         if (ck_stdout == NULL || newterm(s, ck_stdout, stdin) == 0) {
  1587.             fprintf(stderr,
  1588.               "Fullscreen display not supported for terminal type: %srn",s);
  1589.             fdispla = XYFD_S;           /* Use CRT instead */
  1590.             return;
  1591.         }
  1592.         debug(F100,"screenc newterm ok","",0);
  1593. #else
  1594.         debug(F100,"screen calling initscr","",0);
  1595.         initscr();                      /* Initialize curses. */
  1596.         debug(F100,"screen initscr ok","",0);
  1597. #endif /* CK_NEWTERM */
  1598.         cinit++;                        /* Remember curses was initialized. */
  1599. #endif /* COMMENT */
  1600.     }
  1601.     ft_win = 1;                         /* Window is open */
  1602.     if (repaint) {
  1603. #ifdef CK_WREFRESH
  1604. /*
  1605.   This totally repaints the screen, just what we want, but we can only
  1606.   do this with real curses, and then only if clearok() and wrefresh() are
  1607.   provided in the curses library.
  1608. */
  1609. #ifdef OS2
  1610.         RestoreCmdMode();
  1611. #else
  1612. #ifdef QNX
  1613. #ifndef QNX16
  1614.         clearok(stdscr, 1);             /* QNX doesn't have curscr */
  1615. #endif /* QNX16 */
  1616.         wrefresh(stdscr);
  1617. #else
  1618.         wrefresh(curscr);
  1619. #endif /* QNX */
  1620. #endif /* OS2 */
  1621. #else  /* No CK_WREFRESH */
  1622. /*
  1623.   Kermit's do-it-yourself method, works with all types of fullscreen
  1624.   support, but does not repaint all the fields.  For example, the filename
  1625.   is lost, because it arrives at a certain time and never comes again, and
  1626.   Kermit presently does not save it anywhere.  Making this method work for
  1627.   all fields would be a rather major recoding task, and would add a lot of
  1628.   complexity and storage space.
  1629. */
  1630.         cendw = 1;
  1631. #endif /* CK_WREFRESH */
  1632.         repaint = 0;
  1633.     }
  1634.     if (cendw) {                        /* endwin() was called previously */
  1635. #ifdef VMS
  1636.         initscr();                      /* (or should have been!) */
  1637.         clear();
  1638.         touchwin(stdscr);
  1639.         refresh();
  1640. #else
  1641. #ifdef QNX
  1642. /*
  1643.   In QNX, if we don't call initscr() here we core dump.
  1644.   I don't have any QNX curses documentation, but other curses manuals
  1645.   say that initscr() should be called only once per application, and
  1646.   experience shows that on other systems, calling initscr() here generally
  1647.   results in a core dump.
  1648. */
  1649.         debug(F100,"screenc re-calling initscr QNX","",0);
  1650.         initscr();
  1651.         clear();
  1652.         refresh();
  1653. #ifdef COMMENT
  1654. /*
  1655.   But even so, second and subsequent curses displays are messed up.
  1656.   Calling touchwin, refresh, etc, doesn't make any difference.
  1657. */
  1658.         debug(F100,"screenc calling touchwin QNX","",0);
  1659.         touchwin(stdscr);
  1660.         debug(F100,"screenc calling refresh QNX","",0);
  1661.         refresh();
  1662. #endif /* COMMENT */
  1664. #else /* All others... */
  1665.         debug(F100,"screenc calling clear","",0);
  1666.         clear();
  1667.         debug(F100,"screenc clear ok","",0);
  1668. #endif /* QNX */
  1669. #endif /* VMS */
  1670.         debug(F100,"screenc setup ok","",0);
  1671.         debug(F100,"screenc doing first move","",0);
  1672.         move(CW_BAN,0);                 /* Display the banner */
  1673.         debug(F110,"screenc myhost",myhost,0);
  1674. #ifdef TCPSOCKET
  1675.         debug(F110,"screenc myipaddr",myipaddr,0);
  1676. #endif /* TCPSOCKET */
  1677. #ifdef HPUX1010
  1678.         debug(F100,"screenc calling first printw...","",0);
  1679. /* Right here is where HP-UX 10.10 libxcurse.1 Rev 76.20 hangs... */
  1680. #endif /* HPUX1010 */
  1681.         if (myhost[0]) {
  1682. #ifdef TCPSOCKET
  1683.             if (!myipaddr[0]
  1684. #ifdef OS2
  1685.                  /* We need to perform this test because on non-TCP/IP */
  1686.                  /* systems the call to getlocalipaddr() results in a  */
  1687.                  /* DNS Lookup which takes several minutes to time out */
  1688.                  && network &&
  1689.                  (nettype == NET_TCPA || nettype == NET_TCPB)
  1690. #endif /* OS2 */
  1691.                  )
  1692.               getlocalipaddr();
  1693.             if (myipaddr[0] && strcmp((char *)myhost,(char *)myipaddr))
  1694.               printw("%s, %s [%s]",versio,(char *)myhost,(char *)myipaddr);
  1695.             else
  1696. #endif /* TCPSOCKET */
  1697.               printw("%s, %s",versio,(char *)myhost);
  1698.         } else {
  1699.             printw("%s",versio);
  1700.         }
  1701. #ifdef HPUX1010
  1702.         debug(F100,"screenc first printw returns","",0);
  1703. #endif /* HPUX1010 */
  1704.         move(CW_DIR,3);
  1705.         printw("Current Directory: %s",zgtdir());
  1706. #ifdef KUI
  1707. #ifndef K95G
  1708.         KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_DIR, (long) zgtdir() );
  1709. #endif /* K95G */
  1710. #endif /* KUI */
  1711.         if (network) {
  1712.             move(CW_LIN,8);
  1713.             printw("Network Host: %s",ttname);
  1714.         } else {
  1715.             move(CW_LIN,0);
  1716.             printw("Communication Device: %s",ttname);
  1717.         }
  1718. #ifdef KUI
  1719. #ifndef K95G
  1720.         KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_LIN, (long) ttname );
  1721. #endif /* K95G */
  1722. #endif /* KUI */
  1724.         if (network) {
  1725.             move(CW_SPD,8);
  1726.             printw("Network Type: ");
  1727.         } else {
  1728.             move(CW_SPD,1);
  1729.             printw("Communication Speed: ");
  1730.         }
  1731.         move(CW_SPD,22);                /* Serial speed or network type */
  1732.         if (network) {
  1733. #ifdef NETCONN
  1734.             if (0
  1735. #ifdef CK_ENCRYPTION
  1736.                 || ck_tn_encrypting() && ck_tn_decrypting()
  1737. #endif /* CK_ENCRYPTION */
  1738. #ifdef CK_SSL
  1739.                 || tls_active_flag || ssl_active_flag
  1740. #endif /* CK_SSL */
  1741. #ifdef RLOGCODE
  1742. #ifdef CK_KERBEROS
  1743. #ifdef CK_ENCRYPTION
  1744.                 || ttnproto == NP_EK4LOGIN || ttnproto == NP_EK5LOGIN
  1745. #endif /* CK_ENCRYPTION */
  1746. #endif /* CK_KERBEROS */
  1747. #endif /* RLOGCODE */
  1748.                  ) {
  1749. #ifdef KUI
  1750. #ifndef K95G
  1751.                 char buf[30];
  1752.                 sprintf(buf,"%s (SECURE)",netname[nettype]);
  1753.                 KuiSetProperty(KUI_FILE_TRANSFER,
  1754.                                (long) CW_SPD,
  1755.                                (long) buf
  1756.                                );
  1757. #endif /* K95G */
  1758. #endif /* KUI */
  1759.                 printw("%s (SECURE)",netname[nettype]);
  1760.             } else {
  1761.                 printw("%s",netname[nettype]);
  1762. #ifdef KUI
  1763. #ifndef K95G
  1764.                 KuiSetProperty(KUI_FILE_TRANSFER,
  1765.                                (long) CW_SPD,
  1766.                                (long) netname[nettype]
  1767.                                );
  1768. #endif /* K95G */
  1769. #endif /* KUI */
  1770.             }
  1771. #else
  1772.             printw("(network)");
  1773. #ifdef KUI
  1774. #ifndef K95G
  1775.             KuiSetProperty(KUI_FILE_TRANSFER,
  1776.                            (long) CW_SPD,
  1777.                            (long) "(network)"
  1778.                            );
  1779. #endif /* K95G */
  1780. #endif /* KUI */
  1781. #endif /* NETCONN */
  1782.         } else {
  1783.             if (speed < 0L)
  1784.               speed = ttgspd();
  1785.             if (speed > 0L) {
  1786.                 if (speed == 8880) {
  1787.                     printw("75/1200");
  1788. #ifdef KUI
  1789. #ifndef K95G
  1790.                     KuiSetProperty(KUI_FILE_TRANSFER,
  1791.                                    (long) CW_SPD,
  1792.                                    (long) "75/1200"
  1793.                                    );
  1794. #endif /* K95G */
  1795. #endif /* KUI */
  1796.                 } else {
  1797.                     char speedbuf[64] ;
  1798.                     sprintf(speedbuf, "%ld", speed);
  1799.                     printw("%s",speedbuf);
  1800. #ifdef KUI
  1801. #ifndef K95G
  1802.                     KuiSetProperty(KUI_FILE_TRANSFER,
  1803.                                    (long) CW_SPD,
  1804.                                    (long) speedbuf
  1805.                                    );
  1806. #endif /* K95G */
  1807. #endif /* KUI */
  1808.                 }
  1809.             } else {
  1810.                 printw("unknown");
  1811. #ifdef KUI
  1812. #ifndef K95G
  1813.                 KuiSetProperty(KUI_FILE_TRANSFER,
  1814.                                (long) CW_SPD,
  1815.                                (long) "(unknown)"
  1816.                                );
  1817. #endif /* K95G */
  1818. #endif /* KUI */
  1819.             }
  1820.         }
  1821.         move(CW_PAR,14);
  1822.         printw("Parity: %s",parnam((char)parity));
  1823. #ifdef KUI
  1824. #ifndef K95G
  1825.         KuiSetProperty(KUI_FILE_TRANSFER,
  1826.                        (long) CW_PAR,
  1827.                        (long) parnam((char)parity)
  1828.                        );
  1829. #endif /* K95G */
  1830. #endif /* KUI */
  1831. #ifdef CK_TIMERS
  1832.         if (rttflg && protocol == PROTO_K) {
  1833.             move(CW_TMO, 9); printw("RTT/Timeout:"); }
  1834. #endif /* CK_TIMERS */
  1835.         move(CW_TYP,11); printw("File Type:");
  1836.         move(CW_SIZ,11); printw("File Size:");
  1837.         move(CW_PCD, 8);
  1838.         pctlbl = (what == W_SEND);
  1839.         printw("%s:", pctlbl ? "Percent Done" : "Bytes so far");
  1841. #ifdef XYZ_INTERNAL
  1842.         move(CW_BAR, 1);
  1843.         printw("%10s Protocol:",ptab[protocol].p_name);
  1844. #endif /* XYZ_INTERNAL */
  1845. #ifdef CK_PCT_BAR
  1846.         if (thermometer) {
  1847.             oldpct = pct = 0;
  1848.             move(CW_BAR,22);
  1849.             printw("    ...10...20...30...40...50...60...70...80...90..100");
  1850.             move(CW_BAR,22+56);
  1851.         }
  1852. #endif /* CK_PCT_BAR */
  1853.         move(CW_TR,  1); printw("Estimated Time Left:");
  1854.         move(CW_CP,  2); printw("Transfer Rate, CPS:");
  1855.         move(CW_WS,  8); printw("Window Slots:%s",
  1856.                                 protocol == PROTO_K ?
  1857.                                 "" : " N/A"
  1858.                                 );
  1859.         move(CW_PT,  9); printw("Packet Type:");
  1860. #ifdef XYZ_INTERNAL
  1861.         if (protocol != PROTO_K) {
  1862.             move(CW_PC,  11); printw("I/O Count:");
  1863.             move(CW_PL,  10); printw("I/O Length:");
  1864.         } else {
  1865. #endif /* XYZ_INTERNAL */
  1866.             move(CW_PC,  8); printw("Packet Count:");
  1867.             move(CW_PL,  7); printw("Packet Length:");
  1868. #ifdef XYZ_INTERNAL
  1869.         }
  1870. #endif /* XYZ_INTERNAL */
  1871. #ifndef COMMENT
  1872.         move(CW_PR,  9); printw("Error Count:");
  1873. #else
  1874.         move(CW_PR,  2); printw("Packet Retry Count:");
  1875. #endif
  1876. #ifdef COMMENT
  1877.         move(CW_PB,  2); printw("Packet Block Check:");
  1878. #endif /* COMMENT */
  1879.         move(CW_ERR,10); printw("Last Error:");
  1880.         move(CW_MSG, 8); printw("Last Message:");
  1882.         move(CW_INT, 0);
  1883.         if (!xfrint) {
  1884.             printw("(Transfer interruption is disabled)");
  1885.         } else {
  1886. #ifdef CK_NEED_SIG
  1887.             printw(
  1888. "<%s>X to cancel file, <%s>Z to cancel group, <%s><CR> to resend last packet",
  1889.                    dbchr(escape), dbchr(escape), dbchr(escape)
  1890.                    );
  1891.             move(CW_INT + 1, 0);
  1892.             printw(
  1893. "<%s>E to send Error packet, ^C to quit immediately, <%s>L to refresh screen.",
  1894.                    dbchr(escape), dbchr(escape)
  1895.                    );
  1896. #else /* !CK_NEED_SIG */
  1897.             move(CW_INT, 0);
  1898. #ifdef OS2
  1899.             if (protocol == PROTO_K) {
  1900.                 printw(
  1901. "X to cancel file, Z to cancel group, <Enter> to resend last packet,"
  1902.                        );
  1903.             }
  1904. #else /* !OS2 */
  1905. #ifdef VMS                              /* In VMS avoid bottom line */
  1906.             printw(
  1907. "X: Cancel this file; E: Cancel transfer; ^C: Quit now; ^W: Refresh screen."
  1908.                    );
  1909. #else
  1910.             printw(
  1911. "X to cancel file, Z to cancel group, <CR> to resend last packet,"
  1912.                    );
  1913. #endif /* VMS */
  1914. #endif /* OS2 */
  1916. #ifndef VMS
  1917.             move(CW_INT + 1, 0);
  1918.             if (protocol == PROTO_K) {
  1919.                 printw(
  1920. "E to send Error packet, ^C to quit immediately, ^L to refresh screen."
  1921.                        );
  1922.             } else {
  1923.                 printw("^C to cancel file transfer.");
  1924.             }
  1925. #endif /* VMS */
  1926. #endif /* CK_NEED_SIG */
  1927.         }
  1928.         refresh();
  1929.         cendw = 0;
  1930.     }
  1931.     debug(F101,"SCREENC switch","",f);
  1932.     debug(F000,"SCREENC c","",c);
  1933.     debug(F101,"SCREENC n","",n);
  1935.     len = strlen(s);                    /* Length of argument string */
  1936.     switch (f) {                        /* Handle our function code */
  1937.       case SCR_FN:                      /* Filename */
  1938.         oldpct = pct = 0L;              /* Reset percents */
  1939. #ifdef GFTIMER
  1940.         gtv = (CKFLOAT) -1.0;
  1941.         /* oldgtv = (CKFLOAT) -1.0; */
  1942. #else
  1943.         gtv = -1L;
  1944.         /* oldgtv = -1L; */
  1945. #endif /* GFTIMER */
  1946.         oldwin = -1;
  1947.         fsiz = -1L;                     /* Invalidate previous file size */
  1948.         move(CW_PCD,22);                /* Erase percent done from last time */
  1949. #ifdef KUI
  1950. #ifndef K95G
  1951.         KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_PCD, (long) 0 );
  1952.         KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_FFC, (long) 0 );
  1953. #endif /* K95G */
  1954. #endif /* KUI */
  1955.         clrtoeol();
  1956.         move(CW_SIZ,22);                /* Erase file size from last time */
  1957. #ifdef KUI
  1958. #ifndef K95G
  1959.         KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_SIZ, (long) 0 );
  1960. #endif /* K95G */
  1961. #endif /* KUI */
  1962.         clrtoeol();
  1963.         move(CW_ERR,22);                /* And last error message */
  1964. #ifdef KUI
  1965. #ifndef K95G
  1966.         KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_ERR, (long) "" );
  1967. #endif /* K95G */
  1968. #endif /* KUI */
  1969.         clrtoeol();
  1970. #ifdef COMMENT
  1971. #ifdef STREAMING
  1972.         if (protocol == PROTO_K && streamok) {
  1973.             move(CW_BAR, 1);
  1974. #ifdef XYZ_INTERNAL
  1975.             printw("   Kermit STREAMING:");
  1976. #else
  1977.             printw("          STREAMING:");
  1978. #endif /* XYZ_INTERNAL */
  1979.         }
  1980. #endif /* STREAMING */
  1981. #endif /* COMMENT */
  1983.         if (what == W_SEND) {           /* If we're sending... */
  1984. #ifdef CK_RESEND
  1985.             switch (sendmode) {
  1986.               case SM_RESEND:
  1987.                 move(CW_NAM,11);
  1988.                 printw("RESENDING:");
  1989.                 break;
  1990.               default:
  1991.                 move(CW_NAM,13);
  1992.                 printw("SENDING:");
  1993.                 break;
  1994.             }
  1995. #else
  1996.             move(CW_NAM,13);
  1997.             printw("SENDING:");
  1998. #endif /* CK_RESEND */
  2000.         } else if (what == W_RECV) {    /* If we're receiving... */
  2001.             move(CW_NAM,11);
  2002.             printw("RECEIVING:");
  2003.         } else {                        /* If we don't know... */
  2004.             move(CW_NAM,11);            /* (should never see this) */
  2005.             printw("File Name:");
  2006.         }
  2007.         move(CW_NAM,22);                /* Display the filename */
  2008.         if (len > 57) {
  2009.             printw("%.55s..",s);
  2010.             len = 57;
  2011.         } else printw("%s",s);
  2012. #ifdef KUI
  2013. #ifndef K95G
  2014.         KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_NAM, (long) s );
  2015. #endif /* K95G */
  2016. #endif /* KUI */
  2017.         q = len;                        /* Remember name length for later */
  2018.         clrtoeol();
  2019.         scrft();                        /* Display file type (can change) */
  2020.         refresh();
  2021. #ifdef OS2
  2022.         SaveCmdMode(0, 0);
  2023. #endif /* OS2 */
  2024.         return;
  2026.       case SCR_AN:                      /* File as-name */
  2027.         if (q + len + 4 < 58) {         /* Will fit */
  2028.             move(CW_NAM, 22 + q);
  2029.             printw(" => %s",s);
  2030. #ifdef KUI
  2031. #ifndef K95G
  2032.             KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_NAM, (long) s );
  2033. #endif /* K95G */
  2034. #endif /* KUI */
  2035.         } else {                        /* Too long */
  2036.             move(CW_NAM, 22);           /* Overwrite previous name */
  2037.             q = 0;
  2038.             if (len + 4 > 57) {                                 /* wg15 */
  2039.                 printw(" => %.51s..",s);                        /* wg15 */
  2040.                 len = 53;                                       /* wg15 */
  2041.             } else printw(" => %s",s);                          /* wg15 */
  2042. #ifdef KUI
  2043. #ifndef K95G
  2044.             KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_NAM, (long) s  );
  2045. #endif /* K95G */
  2046. #endif /* KUI */
  2047.         }
  2048.         q += len + 4;                   /* Remember horizontal position */
  2049.         clrtoeol();
  2050.         refresh();
  2051. #ifdef OS2
  2052.         SaveCmdMode(0, 0);
  2053. #endif /* OS2 */
  2054.         return;
  2056.       case SCR_FS:                      /* File size */
  2057.         fsiz = n;
  2058.         move(CW_SIZ,22);
  2059.         if (fsiz > -1L) {
  2060. #ifdef KUI
  2061. #ifndef K95G
  2062.             KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_SIZ, (long) n );
  2063. #endif /* K95G */
  2064. #endif /* KUI */
  2065.             printw("%ld",n);
  2066.         }
  2067.         clrtoeol();
  2068.         move(CW_PCD, 8);
  2069.         if (fsiz > -1L) {               /* Put up percent label */
  2070.             pctlbl = 1;
  2071.             printw("Percent Done:");
  2072.         }
  2073.         clrtoeol();
  2074.         scrft();                        /* File type */
  2075.         refresh();
  2076. #ifdef OS2
  2077.         SaveCmdMode(0, 0);
  2078. #endif /* OS2 */
  2079.         return;
  2081.       case SCR_PT:                      /* Packet type or pseudotype */
  2082.         if (spackets < 5) {
  2083.             extern int sysindex;
  2084.             extern struct sysdata sysidlist[];
  2085.             /* Things that won't change after the 4th packet */
  2086.             move(CW_PAR,22);
  2087.             printw("%s",parnam((char)parity));
  2088. #ifdef KUI
  2089. #ifndef K95G
  2090.             KuiSetProperty( KUI_FILE_TRANSFER,
  2091.                            (long) CW_PAR,
  2092.                            (long) parnam((char)parity)
  2093.                            );
  2094. #endif /* K95G */
  2095. #endif /* KUI */
  2096.             clrtoeol();
  2097. #ifdef COMMENT
  2098.             move(CW_PB, 22);            /* Block check on this packet */
  2099.             if (bctu == 4)
  2100.               printw("B");
  2101.             else
  2102.               printw("%d",bctu);
  2103.             clrtoeol();
  2104. #endif /* COMMENT */
  2105.             if (spackets == 4) {
  2106.                 move(CW_LIN,8);
  2107.                 if (protocol == PROTO_K && sysindex > -1) {
  2108.                     if (network) {
  2109.                         move(CW_LIN,8);
  2110.                         printw("Network Host: %s (%s)",
  2111.                              ttname,
  2112.                              sysidlist[sysindex].sid_name
  2113.                              );
  2114.                     }
  2115.                     else {
  2116.                         move(CW_LIN,0);
  2117.                         printw("Communication Device: %s (remote host is %s)",
  2118.                              ttname,
  2119.                              sysidlist[sysindex].sid_name
  2120.                              );
  2121.                     }
  2122.                     clrtoeol();
  2123.                 }
  2124.             }
  2125.         }
  2126. #ifdef CK_TIMERS
  2127.         if (rttflg && protocol == PROTO_K) {
  2128.             long xx;
  2129.             if (
  2130. #ifdef STREAMING
  2131.                 streaming && oldwin != -2
  2132. #else
  2133.                 0
  2134. #endif /* STREAMING */
  2135.                 ) {
  2136.                 move(CW_TMO, 22);
  2137.                 printw("00 / 00");
  2138.                 clrtoeol();
  2139.             } else {
  2140.                 xx = (rttdelay + 500) / 1000;
  2141.                 if (xx != oldrtt || rcvtimo != oldtim) {
  2142.                     move(CW_TMO, 22);
  2143.                     printw("%02ld / %02d", xx, rcvtimo);
  2144.                     oldrtt = xx;
  2145.                     oldtim = rcvtimo;
  2146.                     clrtoeol();
  2147.                 }
  2148.             }
  2149.         }
  2150. #endif /* CK_TIMERS */
  2152.         x = (what == W_RECV) ?          /* Packet length */
  2153.           rpktl+(protocol==PROTO_K?1:0) :
  2154.             spktl;
  2155.         if (x != oldlen) {              /* But only if it changed. */
  2156.             move(CW_PL, 22);
  2157.             printw("%d",x);
  2158. #ifdef KUI
  2159. #ifndef K95G
  2160.             KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_PL, (long) x );
  2161. #endif /* K95G */
  2162. #endif /* KUI */
  2163.             clrtoeol();
  2164.             oldlen = x;
  2165.         }
  2166.         move(CW_PC, 22);                /* Packet count (always). */
  2168.         printw("%d", (what == W_RECV) ? rpackets : spackets);
  2169. #ifdef KUI
  2170. #ifndef K95G
  2171.         KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_PC, (long) spackets );
  2172. #endif /* K95G */
  2173. #endif /* KUI */
  2174.         clrtoeol();
  2176.         if (protocol == PROTO_K) {      /* Window slots */
  2177.             char ws[16];
  2178.             int flag;
  2179.             flag = 0;
  2180. #ifdef STREAMING
  2181.             if (streaming) {
  2182.                 if (oldwin != -2) {
  2183.                     sprintf(ws,"STREAMING");
  2184.                     flag = 1;
  2185.                     oldwin = -2;
  2186.                 }
  2187.             } else
  2188. #endif /* STREAMING */
  2189.               if (wcur != oldwin) {
  2190.                   sprintf(ws, "%d of %d", wcur < 1 ? 1 : wcur, wslotn);
  2191.                   flag = 1;
  2192.                   oldwin = wcur;
  2193.               }
  2194.             if (flag) {
  2195.                 move(CW_WS, 22);
  2196.                 printw("%s", ws);
  2197.                 clrtoeol();
  2198. #ifdef KUI
  2199. #ifndef K95G
  2200.                 KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_WS, (long) ws );
  2201. #endif /* K95G */
  2202. #endif /* KUI */
  2203.             }
  2204.         }
  2205.         errors = retrans + crunched + timeouts;
  2206.         if (errors != oldtry) {         /* Retry count, if changed */
  2207.             move(CW_PR, 22);
  2208.             printw("%d",errors);
  2209. #ifdef KUI
  2210. #ifndef K95G
  2211.             KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_PR, (long) errors );
  2212. #endif /* K95G */
  2213. #endif /* KUI */
  2214.             clrtoeol();
  2215.             oldtry = errors;
  2216.         }
  2217.         if (c != oldtyp && c != 'Y' && c != 'N') { /* Sender's packet type */
  2218.             char type[2];
  2219.             sprintf(type, "%c",c);
  2220.             move(CW_PT,22);
  2221.             printw("%s", type);
  2222. #ifdef KUI
  2223. #ifndef K95G
  2224.             KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_PT, (long) type );
  2225. #endif /* K95G */
  2226. #endif /* KUI */
  2227.             clrtoeol();
  2228.             oldtyp = c;
  2229.         }
  2230.         switch (c) {                    /* Now handle specific packet types */
  2231.           case 'S':                     /* Beginning of transfer */
  2232.             fcnt = fbyt = 0L;           /* Clear counters */
  2233. #ifdef GFTIMER
  2234.             gtv = -1.0;
  2235. #else /* GFTIMER */
  2236.             gtv = -1L;                  /* And old/new things... */
  2237. #endif /* GFTIMER */
  2238.             oldpct = pct = 0L;
  2239.             break;
  2241.           case 'Z':                     /* or EOF */
  2242.             debug(F101,"screenc SCR_PT Z pktnum","",n);
  2243.             debug(F101,"screenc SCR_PT Z oldpct","",oldpct);
  2244.             debug(F101,"screenc SCR_PT Z pct","",pct);
  2245.           case 'D':                     /* Data packet */
  2246.             if (fsiz > 0L) {            /* Show percent done if known */
  2247.                 oldpct = pct;           /* Remember previous percent */
  2248.                 howfar = ffc;
  2249. #ifdef CK_RESEND
  2250.                 if (what == W_SEND)     /* Account for PSEND or RESEND */
  2251.                   howfar += sendstart;
  2252.                 else if (what == W_RECV)
  2253.                   howfar += rs_len;
  2254. #endif /* CK_RESEND */
  2255.                 /* Percent done, to be displayed... */
  2256.                 if (c == 'Z') {
  2257.                     if (!discard && !cxseen && !czseen) pct = 100L;
  2258.                 } else
  2259.                   pct = (fsiz > 99L) ? (howfar / (fsiz / 100L)) : 0L;
  2260.                 if (pct > 100L ||       /* Allow for expansion and */
  2261.                    (oldpct == 99L && pct < 0L)) /* other boundary conditions */
  2262.                   pct = 100L;
  2263.                 if (pct != oldpct)      /* Only do this 100 times per file */
  2264.                   updpct(oldpct, pct);
  2265.             } else {
  2266.                 move(CW_PCD,22);
  2267.                 printw("%ld", ffc);
  2268.             }
  2269. #ifdef KUI
  2270. #ifndef K95G
  2271.             KuiSetProperty(KUI_FILE_TRANSFER, (long) CW_FFC, (long) howfar);
  2272. #endif /* K95G */
  2273. #endif /* KUI */
  2274.             cps = shocps((int) pct, fsiz, howfar);
  2275.             /* old_tr = shoetl(old_tr, cps, fsiz, howfar); */
  2276.             break;
  2278.           case '%':                     /* Timeouts, retransmissions */
  2279.             cps = shocps((int) pct, fsiz, howfar);
  2280.             /* old_tr = shoetl(old_tr, cps, fsiz, howfar); */
  2282.             errors = retrans + crunched + timeouts;
  2283.             if (errors != oldtry) {     /* Error count, if changed */
  2284.                 move(CW_PR, 22);
  2285.                 printw("%d",errors);
  2286.                 clrtoeol();
  2287. #ifdef KUI
  2288. #ifndef K95G
  2289.                 KuiSetProperty(KUI_FILE_TRANSFER,
  2290.                                (long) CW_PR, (long) errors
  2291.                                );
  2292. #endif /* K95G */
  2293. #endif /* KUI */
  2294.                 }
  2295.                 oldtry = errors;
  2296.                 if (s) if (*s) {
  2297.                     move(CW_ERR,22);
  2298.                     printw("%s",s);
  2299.                     clrtoeol();
  2300. #ifdef KUI
  2301. #ifndef K95G
  2302.                     KuiSetProperty(KUI_FILE_TRANSFER, (long) CW_ERR, (long) s);
  2303. #endif /* K95G */
  2304. #endif /* KUI */
  2305.             }
  2306.             break;
  2308.           case 'E':                     /* Error packet */
  2309. #ifdef COMMENT
  2310.             move(CW_ERR,22);            /* Print its data field */
  2311.             if (*s) {
  2312.                 printw("%s",s);
  2313. #ifdef KUI
  2314. #ifndef K95G
  2315.                 KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_ERR, (long) s );
  2316. #endif /* K95G */
  2317. #endif /* KUI */
  2318.             }
  2319.             clrtoeol();
  2320. #endif /* COMMENT */
  2321.             fcnt = fbyt = 0L;           /* So no bytes for this file */
  2322.             break;
  2323.           case 'Q':                     /* Crunched packet */
  2324.             cps = shocps((int) pct, fsiz, howfar);
  2325.             /* old_tr = shoetl(old_tr, cps, fsiz, howfar); */
  2326.             move(CW_ERR,22);
  2327.             printw("Damaged Packet");
  2328. #ifdef KUI
  2329. #ifndef K95G
  2330.             KuiSetProperty(KUI_FILE_TRANSFER,
  2331.                            (long) CW_ERR,
  2332.                            (long) "Damaged Packet"
  2333.                            );
  2334. #endif /* K95G */
  2335. #endif /* KUI */
  2336.             clrtoeol();
  2337.             break;
  2338.           case 'q':                     /* Ctrl-C or connection lost */
  2339.             move(CW_MSG,22);
  2340.             if (!s) s = "";
  2341.             printw(*s ? s : "User interruption or connection lost");
  2342. #ifdef KUI
  2343. #ifndef K95G
  2344.             KuiSetProperty(KUI_FILE_TRANSFER,
  2345.                            (long) CW_MSG,
  2346.                            (long) s
  2347.                            );
  2348. #endif /* K95G */
  2349. #endif /* KUI */
  2350.             break;
  2351.           case 'T':                     /* Timeout */
  2352.             cps = shocps((int) pct, fsiz, howfar);
  2353.             /* old_tr = shoetl(old_tr, cps, fsiz, howfar); */
  2354.             move(CW_ERR,22);
  2355.             printw("Timeout %d sec",rcvtimo);
  2356. #ifdef KUI
  2357. #ifndef K95G
  2358.             KuiSetProperty(KUI_FILE_TRANSFER,
  2359.                            (long) CW_ERR,
  2360.                            (long) "Timeout"
  2361.                            );
  2362. #endif /* K95G */
  2363. #endif /* KUI */
  2364.             clrtoeol();
  2365.             errors = retrans + crunched + timeouts;
  2366.             if (errors != oldtry) {     /* Error count, if changed */
  2367.                 move(CW_PR, 22);
  2368.                 printw("%d",errors);
  2369. #ifdef KUI
  2370. #ifndef K95G
  2371.                 KuiSetProperty(KUI_FILE_TRANSFER,
  2372.                                (long) CW_PR, (long) errors
  2373.                                );
  2374. #endif /* K95G */
  2375. #endif /* KUI */
  2376.                 clrtoeol();
  2377.                 oldtry = errors;
  2378.             }
  2379.             break;
  2380.           default:                      /* Others, do nothing */
  2381.             break;
  2382.         }
  2383.         refresh();
  2384. #ifdef OS2
  2385.         SaveCmdMode(0, 0);
  2386. #endif /* OS2 */
  2387.         return;
  2389.       case SCR_ST:                      /* File transfer status */
  2390.         debug(F101,"screenc SCR_ST c","",c);
  2391.         debug(F101,"screenc SCR_ST success","",success);
  2392.         debug(F101,"screenc SCR_ST cxseen","",cxseen);
  2393. #ifdef COMMENT
  2394.         move(CW_PCD,22);                /* Update percent done */
  2395.         if (c == ST_OK) {               /* OK, print 100 % */
  2396.             if (pctlbl)
  2397.               updpct(oldpct,100);
  2398.             else
  2399.               printw("%ld", ffc);
  2400. #ifdef KUI
  2401. #ifndef K95G
  2402.             KuiSetProperty(KUI_FILE_TRANSFER, (long) CW_FFC, (long) ffc);
  2403. #endif /* K95G */
  2404. #endif /* KUI */
  2405.             pct = 100;
  2406.             oldpct = 0;
  2407.         } else if (fsiz > 0L)           /* Not OK, update final percent */
  2408. /*
  2409.   The else part writes all over the screen -- howfar and/or fsiz have
  2410.   been reset as a consequence of the not-OKness of the transfer.
  2411. */
  2412.           if (pctlbl)
  2413.             updpct(oldpct, (howfar * 100L) / fsiz);
  2414.         clrtoeol();
  2415. #else
  2416.         if (c == ST_OK) {               /* OK, print 100 % */
  2417.             move(CW_PCD,22);            /* Update percent done */
  2418.             if (pctlbl)
  2419.               updpct(oldpct,100);
  2420.             else
  2421.               printw("%ld", ffc);
  2422. #ifdef KUI
  2423. #ifndef K95G
  2424.             KuiSetProperty(KUI_FILE_TRANSFER, (long) CW_FFC, (long) ffc);
  2425. #endif /* K95G */
  2426. #endif /* KUI */
  2427. #ifdef COMMENT
  2428.             pct = 100;
  2429.             oldpct = 0;
  2430. #endif /* COMMENT */
  2431.             clrtoeol();
  2432.         }
  2433. #endif /* COMMENT */
  2435. #ifdef COMMENT
  2436. /* No, leave it there so they can read it */
  2437.         move(CW_MSG,22);                /* Remove any previous message */
  2438. #ifdef KUI
  2439. #ifndef K95G
  2440.         KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_MSG, (long) "" );
  2441. #endif /* K95G */
  2442. #endif /* KUI */
  2443.         clrtoeol(); refresh();
  2444. #endif /* COMMENT */
  2446.         move(CW_TR, 22);
  2447. #ifdef KUI
  2448. #ifndef K95G
  2449.         KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_TR, (long) "" );
  2450. #endif /* K95G */
  2451. #endif /* KUI */
  2452.         clrtoeol(); refresh();
  2454.         switch (c) {                    /* Print new status message */
  2455.           case ST_OK:                   /* Transfer OK */
  2456.             fcnt++;                     /* Count this file */
  2457.             fbyt += ffc;                /* Count its bytes */
  2458.             move(CW_MSG,22);
  2459.             printw("Transfer OK");      /* Say Transfer was OK */
  2460. #ifdef KUI
  2461. #ifndef K95G
  2462.             KuiSetProperty(KUI_FILE_TRANSFER,
  2463.                            (long) CW_MSG,
  2464.                            (long) "Transfer OK"
  2465.                            );
  2466. #endif /* K95G */
  2467. #endif /* KUI */
  2468.             clrtoeol(); refresh();
  2469.             return;
  2471.           case ST_DISC:                 /* Discarded */
  2472.             move(CW_ERR,22);
  2473.             printw("File discarded");
  2474. #ifdef KUI
  2475. #ifndef K95G
  2476.             KuiSetProperty(KUI_FILE_TRANSFER,
  2477.                            (long) CW_ERR,
  2478.                            (long) "File discarded"
  2479.                            );
  2480. #endif /* K95G */
  2481. #endif /* KUI */
  2482. #ifdef COMMENT
  2483.             pct = oldpct = 0;
  2484. #endif /* COMMENT */
  2485.             clrtoeol(); refresh();
  2486.             return;
  2488.           case ST_INT:                  /* Interrupted */
  2489.             move(CW_ERR,22);
  2490.             printw("Transfer interrupted");
  2491. #ifdef KUI
  2492. #ifndef K95G
  2493.             KuiSetProperty(KUI_FILE_TRANSFER,
  2494.                            (long) CW_ERR,
  2495.                            (long) "Transfer interrupted"
  2496.                            );
  2497. #endif /* K95G */
  2498. #endif /* KUI */
  2499. #ifdef COMMENT
  2500.             pct = oldpct = 0;
  2501. #endif /* COMMENT */
  2502.             clrtoeol(); refresh();
  2503.             return;
  2505.           case ST_SKIP:                 /* Skipped */
  2506.             move(CW_ERR,22);
  2507.             printw("File skipped");
  2508. #ifdef KUI
  2509. #ifndef K95G
  2510.             KuiSetProperty(KUI_FILE_TRANSFER,
  2511.                            (long) CW_ERR,
  2512.                            (long) "File skipped"
  2513.                            );
  2514. #endif /* K95G */
  2515. #endif /* KUI */
  2516. #ifdef COMMENT
  2517.             pct = oldpct = 0;
  2518. #endif /* COMMENT */
  2519.             clrtoeol(); refresh();
  2520.             return;
  2522.           case ST_ERR:                  /* Error message */
  2523.             move(CW_ERR,22);
  2524.             if (!s) s = (char *)epktmsg;
  2525.             printw("%s",s);
  2526. #ifdef KUI
  2527. #ifndef K95G
  2528.             KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_ERR, (long) s );
  2529. #endif /* K95G */
  2530. #endif /* KUI */
  2531. #ifdef COMMENT
  2532.             pct = oldpct = 0;
  2533. #endif /* COMMENT */
  2534.             clrtoeol(); refresh();
  2535.             return;
  2537.           case ST_REFU:                 /* Refused */
  2538.             move(CW_ERR,22);
  2539.             if (*s) {
  2540.                 char errbuf[64] ;
  2541.                 sprintf( errbuf, "Refused, %s", s ) ;
  2542.                 printw("%s", errbuf);
  2543. #ifdef KUI
  2544. #ifndef K95G
  2545.                 KuiSetProperty(KUI_FILE_TRANSFER,(long) CW_ERR,(long) errbuf);
  2546. #endif /* K95G */
  2547. #endif /* KUI */
  2548.             } else {
  2549.                 printw("Refused");
  2550. #ifdef KUI
  2551. #ifndef K95G
  2552.                 KuiSetProperty(KUI_FILE_TRANSFER,(long)CW_ERR,(long)"Refused");
  2553. #endif /* K95G */
  2554. #endif /* KUI */
  2555.             }
  2556. #ifdef COMMENT
  2557.             pct = oldpct = 0;
  2558. #endif /* COMMENT */
  2559.             clrtoeol(); refresh();
  2560.             return;
  2562.           case ST_INC:
  2563.             move(CW_ERR,22);
  2564.             printw("Incomplete");
  2565. #ifdef KUI
  2566. #ifndef K95G
  2567.             KuiSetProperty(KUI_FILE_TRANSFER,(long)CW_ERR,(long)"Incomplete");
  2568. #endif /* K95G */
  2569. #endif /* KUI */
  2570. #ifdef COMMENT
  2571.             pct = oldpct = 0;
  2572. #endif /* COMMENT */
  2573.             clrtoeol(); refresh();
  2574.             return;
  2576.           case ST_MSG:
  2577.             move(CW_MSG,22);
  2578.             printw("%s",s);
  2579. #ifdef KUI
  2580. #ifndef K95G
  2581.             KuiSetProperty(KUI_FILE_TRANSFER,(long)CW_MSG,(long)s);
  2582. #endif /* K95G */
  2583. #endif /* KUI */
  2584.             clrtoeol(); refresh();
  2585.             return;
  2587.           default:                      /* Bad call */
  2588.             move(CW_ERR,22);
  2589.             printw("*** screen() called with bad status ***");
  2590. #ifdef KUI
  2591. #ifndef K95G
  2592.             KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_ERR,
  2593.                        (long) "*** screen() called with bad status ***" );
  2594. #endif /* K95G */
  2595. #endif /* KUI */
  2596.             clrtoeol(); refresh(); return;
  2597.         }
  2599.       case SCR_TC: {                    /* Transaction complete */
  2600.           char msgbuf[128];
  2601.           int eff = -1;
  2602.           move(CW_CP,22);               /* Overall transfer rate */
  2603. #ifdef KUI
  2604. #ifndef K95G
  2605.           KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_CP, tfcps);
  2606. #endif /* K95G */
  2607. #endif /* KUI */
  2608.           printw("%ld", tfcps);
  2609.           clrtoeol();
  2610.           if (success) {
  2611.               move(CW_MSG,22);          /* Print statistics in message line */
  2612.               clrtoeol();
  2613.           }
  2614.           if (success) {
  2615.               sprintf(msgbuf,
  2616.                       "SUCCESS.  Files: %ld, Bytes: %ld, %ld CPS",
  2617.                       fcnt,
  2618.                       fbyt,
  2619.                       tfcps
  2620.                       );
  2621.               printw("%s", msgbuf);
  2622. #ifdef KUI
  2623. #ifndef K95G
  2624.               KuiSetProperty(KUI_FILE_TRANSFER,
  2625.                              (long) CW_MSG,
  2626.                              (long) msgbuf
  2627.                              );
  2628. #endif /* K95G */
  2629. #endif /* KUI */
  2630.               clrtoeol();
  2632.           }
  2633.           move(CW_TR, 1);
  2634.           printw("       Elapsed Time: %s",hhmmss((long)
  2635. #ifdef GFTIMER
  2636.                                                   (fptsecs + 0.5)
  2637. #else
  2638.                                                   tsecs
  2639. #endif /* GFTIMER */
  2640.                                                    ));
  2641. #ifdef KUI
  2642. #ifndef K95G
  2643.           KuiSetProperty(KUI_FILE_TRANSFER,
  2644.                          (long) CW_TR,
  2645.                          (long) hhmmss((long)
  2646. #ifdef GFTIMER
  2647.                                        (fptsecs + 0.5)
  2648. #else
  2649.                                        tsecs
  2650. #endif /* GFTIMER */
  2651.                                        ));
  2652. #endif /* K95G */
  2653. #endif /* KUI */
  2654.           clrtoeol();
  2655.           move(23,0); clrtoeol();       /* Clear instructions lines */
  2656.           move(22,0); clrtoeol();       /* to make room for prompt. */
  2657.           refresh();
  2659. #ifdef GFTIMER
  2660.           oldgtv = (CKFLOAT) -1.0;
  2661. #else
  2662.           oldgtv = -1L;
  2663. #endif /* GFTIMER */
  2665. #ifndef VMSCURSE
  2666.           endwin();
  2667. #ifdef SOLARIS
  2668.           conres();
  2669. #endif /* SOLARIS */
  2670. #endif /* VMSCURSE */
  2671. #ifdef COMMENT
  2672.           pct = 100; oldpct = 0;        /* Reset these for next time. */
  2673. #endif /* COMMENT */
  2674.           oldtyp = 0; oldrtt = -1L; oldtry = -1; oldlen = -1;
  2675.           oldtim = -1;
  2676.           cendw = 1;
  2677.           if (xfrbel) bleep(BP_NOTE);   /* Close window, then beep. */
  2678. #ifdef UNIX
  2679.           fflush(stdout);
  2680. #endif /* UNIX */
  2681.           ft_win = 0;                   /* Window closed. */
  2682.           return;
  2683.       }
  2684.       case SCR_EM:                      /* Error packet (fatal) */
  2685.         move (CW_ERR,22);
  2686.         printw("FAILURE: %s",s);
  2687. #ifdef KUI
  2688. #ifndef K95G
  2689.         KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_ERR, (long) s );
  2690. #endif /* K95G */
  2691. #endif /* KUI */
  2692.         if (xfrbel) bleep(BP_FAIL);
  2693. #ifdef COMMENT
  2694.         pct = oldpct = 0;
  2695. #endif /* COMMENT */
  2696.         clrtoeol(); refresh(); return;
  2698.       case SCR_QE:                      /* Quantity equals */
  2699.       case SCR_TU:                      /* Undelimited text */
  2700.       case SCR_TN:                      /* Text delimited at start */
  2701.       case SCR_TZ:                      /* Text delimited at end */
  2702.         return;                         /* (ignored in fullscreen display) */
  2704.       case SCR_XD:                      /* X-packet data */
  2705.         pct = oldpct = 0;
  2706.         move(CW_NAM,22);
  2707.         printw("%s",s);
  2708. #ifdef KUI
  2709. #ifndef K95G
  2710.         KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_NAM, (long) s );
  2711. #endif /* K95G */
  2712. #endif /* KUI */
  2713.         clrtoeol(); refresh(); return;
  2715.       case SCR_CW:                      /* Close Window */
  2716.         clrtoeol(); move(23,0); clrtoeol(); move(22,0); clrtoeol();
  2717.         refresh();
  2718. #ifdef COMMENT
  2719.         pct = 100; oldpct = 0;          /* Reset these for next time. */
  2720. #endif /* COMMENT */
  2721.         oldtyp = 0; oldrtt = -1L; oldtry = -1; oldlen = -1;
  2722.         oldtim = -1;
  2724. #ifndef VMSCURSE
  2725.         endwin();
  2726. #endif /* VMSCURSE */
  2727.         ft_win = 0;                     /* Flag that window is closed. */
  2728.         cendw = 1; return;
  2730.       case SCR_CD:                      /* Display current directory */
  2731.         move(CW_DIR,22);
  2732.          printw("%s", s);
  2733. #ifdef KUI
  2734. #ifndef K95G
  2735.         KuiSetProperty( KUI_FILE_TRANSFER, (long) CW_DIR, (long) s );
  2736. #endif /* K95G */
  2737. #endif /* KUI */
  2738.         clrtoeol();
  2739.         refresh();
  2740. #ifdef OS2
  2741.         SaveCmdMode(0, 0);
  2742. #endif /* OS2 */
  2743.         return;
  2745.       default:                          /* Bad call */
  2746.         move (CW_ERR,22);
  2747. #ifdef KUI
  2748. #ifndef K95G
  2749.         KuiSetProperty(KUI_FILE_TRANSFER,
  2750.                        (long) CW_ERR,
  2751.                        (long) "*** screen() called with bad function code ***"
  2752.                        );
  2753. #endif /* K95G */
  2754. #endif /* KUI */
  2755.         printw("*** screen() called with bad function code ***");
  2756.         clrtoeol(); refresh(); return;
  2757.     }
  2758. }
  2759. #endif /* CK_CURSES */
  2760. #endif /* MAC */
  2762. #ifndef CK_CURPOS
  2763. /* Dummies for when cursor control is not supported */
  2764. int
  2765. ck_curpos(row, col) {
  2766.     return(-1);
  2767. }
  2769. int
  2770. ck_cls() {
  2771.     return(-1);
  2772. }
  2774. int
  2775. ck_cleol() {
  2776.     return(-1);
  2777. }
  2778. #endif /* CK_CURPOS */
  2780. #ifndef NOIKSD
  2781. #ifdef IKSDB
  2783. struct iksdbfld dbfld[] = {
  2784.    /* Offset    Length    Type   */
  2785.     { DB_FLAGS, dB_FLAGS, DBT_HEX },    /*  0 db_FLAGS Flags */
  2786.     { DB_ATYPE, dB_ATYPE, DBT_HEX },    /*  1 db_ATYPE Auth type */
  2787.     { DB_AMODE, dB_AMODE, DBT_HEX },    /*  3 db_AMODE Auth mode */
  2788.     { DB_STATE, dB_STATE, DBT_HEX },    /*  2 db_STATE State */
  2789.     { DB_MYPID, dB_MYPID, DBT_HEX },    /*  5 db_MYPID PID */
  2790.     { DB_SADDR, dB_SADDR, DBT_HEX },    /*  4 db_SADDR Server address */
  2791.     { DB_CADDR, dB_CADDR, DBT_HEX },    /*  6 db_CADDR Client address */
  2792.     { DB_START, dB_START, DBT_DAT },    /*  7 db_START Session start */
  2793.     { DB_LASTU, dB_LASTU, DBT_DAT },    /*  8 db_LASTU Last update */
  2794.     { DB_ULEN,  dB_ULEN,  DBT_HEX },    /*  9 db_ULEN  Username length */
  2795.     { DB_DLEN,  dB_DLEN,  DBT_HEX },    /* 10 db_DLEN  Directory name length */
  2796.     { DB_ILEN,  dB_ILEN,  DBT_HEX },    /* 11 db_ILEN  Info length */
  2797.     { DB_PAD1,  dB_PAD1,  DBT_UND },    /* 12 db_PAD1  (Reserved) */
  2798.     { DB_USER,  dB_USER,  DBT_STR },    /* 13 db_USER  Username */
  2799.     { DB_DIR,   dB_DIR,   DBT_STR },    /* 14 db_DIR   Current Directory */
  2800.     { DB_INFO,  dB_INFO,  DBT_STR }     /* 15 db_INFO  State-specific info */
  2801. };
  2803. static char lcknam[CKMAXPATH+1];        /* Lockfile pathname */
  2804. static char tmplck[CKMAXPATH+1];        /* Temporary lockfile name */
  2806. static char * updmode =                 /* Update mode for fopen() */
  2807. #ifdef OS2
  2808.   "r+b"
  2809. #else
  2810. #ifdef VMS
  2811.   "r+b"
  2812. #else
  2813.   "r+"
  2814. #endif /* VMS */
  2815. #endif /* OS2 */
  2816.   ;
  2818. /*  D B I N I T  --  Initialize the IKSD database...  */
  2820. int
  2821. dbinit() {
  2822.     extern int dbinited;
  2823.     int x = 0;
  2824.     debug(F110,"dbinit dbdir 1",dbdir,0);
  2825.     debug(F110,"dbinit dbfile 1",dbfile,0);
  2826.     if (dbinited)
  2827.       return(0);
  2828. #ifdef OS2
  2829.     if (!dbdir) {
  2830. #ifdef NT
  2831.         char * p = NULL;
  2832.         if (!isWin95()) {
  2833.             p = getenv("SystemRoot");
  2834.         } else {
  2835.             p = getenv("winbootdir");
  2836.             if (!p)  p = getenv("windir");
  2837.         }
  2838.         if (!p) p = "C:/";
  2839.         dbdir = malloc(strlen(p)+2);
  2840.         strcpy(dbdir,p);
  2841.         p = dbdir;
  2842.         while (*p) {
  2843.             if (*p == '\')
  2844.               *p = '/';
  2845.             p++;
  2846.         }
  2847. #else /* NT */
  2848.         makestr(&dbdir,"C:/");
  2849. #endif /* NT */
  2850.     }
  2851. #else /* OS2 */
  2852.     if (!dbdir)
  2853.       makestr(&dbdir,IK_DBASEDIR);
  2854. #endif /* OS2 */
  2856.     if (!dbfile) {
  2857.         char * s = "";
  2858.         x = strlen(dbdir);
  2859.         if (dbdir[x-1] != '/') {
  2860.             s = "/";
  2861.             x++;
  2862.         }
  2863.         x += (int)strlen(IK_DBASEFIL);
  2864.         dbfile = (char *)malloc(x+1);
  2865.         sprintf(dbfile,"%s%s%s",dbdir,s,IK_DBASEFIL);
  2866.     }
  2867.     debug(F110,"dbinit dbdir 2",dbdir,0);
  2868.     debug(F110,"dbinit dbfile 2",dbfile,0);
  2869.     mypid = getpid();                   /* Get my pid */
  2870.     debug(F101,"dbinit mypid","",mypid);
  2872.     if (!myhexip[0]) {                  /* Set my hex IP address */
  2873. #ifdef TCPSOCKET
  2874.         extern unsigned long myxipaddr;
  2875.         if (getlocalipaddr() > -1) {
  2876.             myip = myxipaddr;
  2877.             sprintf(myhexip,"%08lx",myip); /* (Needs fixing for IPv6) */
  2878.         } else
  2879. #endif /* TCPSOCKET */
  2880.           ckstrncpy(myhexip,"00000000",9);
  2881.     }
  2882.     debug(F011,"dbinit myip",myhexip,myip);
  2883.     if (!peerhexip[0]) {                /* Get peer's  hex IP address */
  2884. #ifdef TCPSOCKET
  2885.         extern unsigned long peerxipaddr;
  2886.         if (ckgetpeer()) {
  2887.             peerip = peerxipaddr;
  2888.             sprintf(peerhexip,"%08lx",peerip); /* (Needs fixing for IPv6) */
  2889.             debug(F011,"dbinit peerip",peerhexip,peerip);
  2890.         } else {
  2891.             debug(F101,"dbinit ckgetpeer failure","",errno);
  2892.             ckstrncpy(peerhexip,"00000000",9);
  2893.         }
  2894. #else
  2895.         ckstrncpy(peerhexip,"00000000",9);
  2896. #endif /* TCPSOCKET */
  2897.     }
  2898.     debug(F111,"dbinit peerip",peerhexip,peerip);
  2899.     debug(F101,"dbinit dbenabled","",dbenabled);
  2900.     if (dbenabled && inserver) {
  2901.         mydbslot = getslot();
  2902.         debug(F111,"dbinit getslot",ckitoa(ikdbopen),x);
  2903.         if (ikdbopen) dbinited = 1;
  2904.     }
  2905.     return(0);
  2906. }
  2908. /*  U P D S L O T  --  Update slot n  */
  2910. /*
  2911.   Opens the database if necessary, seeks to slot n, writes current record
  2912.   and adds current time to last-update field.  n is the record sequence number
  2913.   (0, 1, 2, ...), not the seek pointer.   Returns -1 on failure, 0 on success.
  2914. */
  2915. int
  2916. updslot(n) int n; {                     /* Update our slot */
  2917.     int x, rc = 0;
  2918.     long position;
  2919.     if (!ikdbopen)                      /* Not if not ok */
  2920.       return(0);
  2921.     if (!dbfp) {                        /* Open database if not open */
  2922.         dbfp = fopen(dbfile,updmode);   /* In update no-truncate mode */
  2923.         if (!dbfp) {
  2924.             debug(F110,"updslot fopen failed",dbfile,0);
  2925.             ikdbopen = 0;
  2926.             return(-1);
  2927.         }
  2928.     }
  2929.     position = n * DB_RECL;
  2930.     if (fseek(dbfp,position,0) < 0) {   /* Seek to desired slot */
  2931.         debug(F111,"updslot fseek failed",dbfile,mydbseek);
  2932.         ikdbopen = 0;
  2933.         rc = -1;
  2934.     } else {
  2935.         /* Update the update time */
  2936.         strncpy(&dbrec[dbfld[db_LASTU].off],
  2937.                 ckdate(),
  2938.                 dbfld[db_LASTU].len
  2939.                 );
  2940.         if (fwrite(dbrec,1,DB_RECL,dbfp) < DB_RECL) { /* Write the record */
  2941.             debug(F110,"updslot fwrite failed",dbfile,0);
  2942.             ikdbopen = 0;
  2943.             rc = -1;
  2944.         } else {                        /* Flush the write */
  2945.             fflush(dbfp);
  2946.         }
  2947.     }
  2948.     return(rc);
  2949. }
  2951. /*  I N I T S L O T --  Initialize slot n with my info  */
  2953. int
  2954. initslot(n) int n; {                    /* Initialize slot */
  2955.     int i, j, k;
  2956.     char * s;
  2957. #ifdef TCPSOCKET
  2958.     extern unsigned long peerxipaddr;
  2959. #endif /* TCPSOCKET */
  2961.     debug(F101,"initslot","",n);
  2963. #ifdef USE_MEMCPY
  2964.     memset(dbrec,32,DB_RECL);
  2965. #else
  2966.     for (i = 0; i < DB_RECL; i++)
  2967.       dbrec[i] = '40';
  2968. #endif /* USE_MEMCPY */
  2970.     myflags = DBF_INUSE;                /* Set in-use flag */
  2971.     mystate = W_NOTHING;
  2972.     myatype = 0L;
  2973.     myamode = 0L;
  2975.     k = dbfld[db_FLAGS].len;            /* Length of flags field */
  2976.     strncpy(&dbrec[dbfld[db_FLAGS].off],ulongtohex(myflags,k),k);
  2978.     k = dbfld[db_ATYPE].len;
  2979.     strncpy(&dbrec[dbfld[db_ATYPE].off],ulongtohex(myatype,k),k);
  2981.     k = dbfld[db_AMODE].len;
  2982.     strncpy(&dbrec[dbfld[db_AMODE].off],ulongtohex(myamode,k),k);
  2984.     k = dbfld[db_STATE].len;
  2985.     strncpy(&dbrec[dbfld[db_STATE].off],ulongtohex(mystate,k),k);
  2987.     k = dbfld[db_SADDR].len;
  2988.     strncpy(&dbrec[dbfld[db_SADDR].off],ulongtohex(myip,k),k);
  2990. #ifdef TCPSOCKET
  2991.     ckgetpeer();
  2992.     k = dbfld[db_CADDR].len;
  2993.     strncpy(&dbrec[dbfld[db_CADDR].off],ulongtohex(peerxipaddr,k),k);
  2994. #else
  2995.     k = dbfld[db_CADDR].len;
  2996.     strncpy(&dbrec[dbfld[db_CADDR].off],ulongtohex(0L,k),k);
  2997. #endif /* TCPSOCKET */
  2999.     k = dbfld[db_MYPID].len;
  3000.     strncpy(&dbrec[dbfld[db_MYPID].off],ulongtohex(mypid,k),k);
  3002.     k = dbfld[db_START].len;
  3003.     strncpy(&dbrec[dbfld[db_START].off],ckdate(),k);
  3005.     k = dbfld[db_ULEN].len;
  3006.     strncpy(&dbrec[dbfld[db_ULEN].off],"0000",4);
  3008.     k = dbfld[db_DLEN].len;
  3009.     strncpy(&dbrec[dbfld[db_DLEN].off],"0000",4);
  3011.     k = dbfld[db_ILEN].len;
  3012.     strncpy(&dbrec[dbfld[db_ILEN].off],"0000",4);
  3014.     strncpy(&dbrec[dbfld[db_INFO].off],"INIT",4);
  3015.     return(updslot(n));
  3016. }
  3018. int
  3019. slotstate(x,s1,s2,s3) int x; char *s1, *s2, *s3; {
  3020.     int k, l1, l2, l3, z;
  3021.     mystate = x;
  3022.     debug(F101,"slotstate ikdbopen","",ikdbopen);
  3023.     if (!ikdbopen)
  3024.       return(-1);
  3025.     if (!s1) s1 = "";
  3026.     l1 = strlen(s1);
  3027.     if (!s2) s2 = "";
  3028.     l2 = strlen(s2);
  3029.     if (!s3) s3 = "";
  3030.     l3 = strlen(s3);
  3031.     strncpy(&dbrec[DB_STATE],ulongtohex(mystate,4),4);
  3032.     k = dbfld[db_ILEN].len;
  3033.     z = l1 + l2 + l3 + 2;
  3034.     if (z > dB_INFO)
  3035.       z = dB_INFO;
  3036.     strncpy(&dbrec[DB_ILEN],ulongtohex((unsigned long)z,k),k);
  3037.     k = dbfld[db_INFO].len;
  3038.     z = dbfld[db_INFO].off;
  3039.     if (l1 <= k) {
  3040.         lset(&dbrec[z],s1,l1+1,32);
  3041.         z += l1+1;
  3042.         k -= l1+1;
  3043.         if (l2 <= k) {
  3044.             lset(&dbrec[z],s2,l2+1,32);
  3045.             z += l2+1;
  3046.             k -= l2+1;
  3047.             if (l3 <= k)
  3048.               lset(&dbrec[z],s3,k,32);
  3049.         }
  3050.     }
  3051. #ifdef DEBUG
  3052.     if (deblog) {
  3053.         char buf[128];
  3054.         int i;
  3055.         strncpy(buf,&dbrec[DB_INFO],127);
  3056.         buf[127] = NUL;
  3057.         for (i = 126; i > 0 && buf[i] == 32; i--) buf[i] = 0;
  3058.         debug(F111,"slotstate",buf,mystate);
  3059.     }
  3060. #endif /* DEBUG */
  3061.     z = updslot(mydbslot);
  3062.     debug(F111,"slotstate updslot","",z);
  3063.     return(z);
  3064. }
  3066. int
  3067. slotdir(s1,s2) char * s1, * s2; {       /* Update current directory */
  3068.     int k, len1, len2;
  3069.     if (!ikdbopen)
  3070.       return(-1);
  3071.     if (!s1) s1 = "";
  3072.     if (!s2) s2 = "";
  3073.     len1 = strlen(s1);
  3074.     len2 = strlen(s2);
  3075.     k = dbfld[db_DLEN].len;
  3076.     strncpy(&dbrec[DB_DLEN],ulongtohex((unsigned long)(len1+len2),k),k);
  3077.     k = dbfld[db_DIR].len;
  3078.     if (len1 > 0) {
  3079.         lset(&dbrec[dbfld[db_DIR].off],s1,len1,32);
  3080.         lset(&dbrec[dbfld[db_DIR].off+len1],s2,k-len1,32);
  3081.     } else {
  3082.         lset(&dbrec[dbfld[db_DIR].off],s2,k,32);
  3083.     }
  3084.     return(updslot(mydbslot));
  3085. }
  3087. /*  F R E E S L O T  --  Free slot n  */
  3089. int
  3090. freeslot(n) int n; {
  3091.     int k;
  3092.     if (!ikdbopen)
  3093.       return(0);
  3094.     dbflags = 0L;
  3095.     if (n == mydbslot) {
  3096.         dbflags = myflags & ~DBF_INUSE;
  3097.         dbflags &= ~DBF_LOGGED;
  3098.     }
  3099.     k = dbfld[db_FLAGS].len;
  3100.     strncpy(&dbrec[dbfld[db_FLAGS].off],ulongtohex(dbflags,k),k);
  3101.     return(updslot(n));
  3102. }
  3104. /*  G E T S L O T  --  Find a free database slot; returns slot number  */
  3106. int
  3107. getslot() {                             /* Find a free slot for us */
  3108.     FILE * rfp = NULL;                  /* Returns slot number (0, 1, ...) */
  3109.     char idstring[64];                  /* PID string buffer (decimal) */
  3110.     char pidbuf[64], * s;
  3111.     int j, k, n, x, rc = -1;
  3112.     int lockfd, tries, haveslot = 0;
  3113.     long lockpid, i;
  3114.     char ipbuf[17];
  3116.     if (!myhexip[0])                    /* Set my hex IP address if not set */
  3117.       ckstrncpy((char *)myhexip,"7F000001",33);
  3118.     sprintf(idstring,"%08lx:%010ldn",myip,mypid);
  3119.     debug(F110,"getslot idstring", idstring, 0);
  3121.     /* Make temporary lockfile name IP.PID (hex.hex) */
  3122.     /* This should fit in 14 chars -- huge PIDs are usually not possible */
  3123.     /* on 14-char filename systems. */
  3125.     sprintf(tmplck,"%s%08lx.%lx",dbdir,myip,mypid);
  3126.     debug(F110,"getslot tempfile",tmplck,0);
  3128.     /* Make a temporary file */
  3130.     lockfd = creat(tmplck, 0600);
  3131.     if (lockfd < 0) {
  3132.         debug(F111,"getslock temp lockfile create failure", tmplck, errno);
  3133.         return(-1);
  3134.     }
  3135.     /* Write my (decimal) PID into the temp file */
  3137.     write(lockfd,idstring,(int)strlen(idstring));
  3138.     if (close(lockfd) < 0) {            /* Close lockfile */
  3139.         debug(F101,"getslot error closing temp lockfile", "", errno);
  3140.         return(-1);
  3141.     }
  3142.     sprintf(lcknam,"%s%s",dbdir,IK_LOCKFILE); /* Build lockfile name */
  3143.     debug(F110,"getslot lockfile",lcknam,0);
  3145.     rfp = fopen(lcknam,"r");            /* See if lockfile exists */
  3146.     if (rfp) {                          /* If so... */
  3147.         int sameip = 0;
  3148.         rset(pidbuf,"",64,0);
  3149.         x = fread(pidbuf,1,63,rfp);     /* Read ID string from it */
  3150.         fclose(rfp);                    /* and close it quickly */
  3151.         debug(F110,"getslot lock exists",pidbuf,0);
  3152.         if (x > 0) {                    /* If we have a PID, check it */
  3153.             char * s = pidbuf;
  3154.             while (*s) {
  3155.                 if (islower(*s)) *s = toupper(*s);
  3156.                 if (*s == ':') {
  3157.                     *s = NUL;
  3158.                     debug(F110,"getslot lock IP",pidbuf,0);
  3159.                     debug(F110,"gteslot my   IP",myhexip,0);
  3160.                     if (!strcmp(pidbuf,myhexip)) { /* Same IP address? */
  3161.                         lockpid = atol(s+1); /* Yes, now get PID */
  3162.                         debug(F101,"getslot lockpid","",lockpid);
  3164.                         /* Check if PID lockpid on this computer is alive */
  3165.                         x = zchkpid(lockpid);
  3166.                         if (!x) {
  3167.                             debug(F100,"getslot PID stale,removing lock","",0);
  3168.                             unlink(lcknam);
  3169.                         }
  3170.                         break;
  3171.                     }
  3172.                 }
  3173.                 s++;
  3174.             }
  3175.         } else {
  3176.             debug(F111,"getslot lockfile open failure",lcknam,errno);
  3177.         }
  3178.     }
  3179.     /* Try IK_LCKTRIES (16) times to rename temp file to lockfile */
  3181.     for (tries = IK_LCKTRIES; tries > 0; tries--) {
  3182.         if (zrename(tmplck,lcknam) == 0)
  3183.           break;
  3184.         debug(F101,"getslot database locked by pid", "", dbpid);
  3185.         sleep(IK_LCKSLEEP);
  3186.     }
  3187.     if (tries < 1) {                    /* Couldn't */
  3188.         debug(F110,"getslot create lock failure",lcknam,0);
  3189.         return(-1);
  3190.     }
  3191.     /* Have lock, open database */
  3193.     debug(F110,"getslot has lock",lcknam,0); /* Have lock */
  3195.     if (!dbfile)
  3196.       return(-1);
  3198.     /* If database doesn't exist, create it. */
  3200.     debug(F110,"getslot dbfile",dbfile,0);
  3201.     if (zchki(dbfile) < 0) {
  3202.         debug(F110,"getslot creating new database",dbfile,0);
  3203.         x = creat(dbfile,0660);
  3204.         if (x < 0) {
  3205.             debug(F111,"getslot creat() failed", dbfile, errno);
  3206.             goto xslot;
  3207.         }
  3208.         close(x);
  3209.     }
  3210.     dbfp = fopen(dbfile,updmode);       /* Open it in update mode */
  3211.     if (!dbfp) {
  3212.         debug(F111,"getslot fopen failed",dbfile,errno);
  3213.         goto xslot;
  3214.     }
  3215.     /* Now find a free (or new) slot... */
  3217.     dblastused = 0L;                    /* Seek pointer to last record inuse */
  3218.     mydbseek = 0L;                      /* Seek pointer for my record */
  3220.     /* Quickly read the whole database; n = record counter, i = seek pointer */
  3222.     for (n = 0, i = 0; !feof(dbfp); i += DB_RECL, n++) {
  3223.         x = fread(dbrec,1,DB_RECL,dbfp); /* Read a record */
  3224.         if (x < 1)                      /* EOF not caught by feof() */
  3225.           break;
  3226. #ifndef NOFTRUNCATE
  3227.         if (x != DB_RECL) {             /* Watch out for trailing junk */
  3228.             debug(F101,"getslot bad size","",x);  /* (Shouldn't happen...) */
  3229. #ifdef COHERENT
  3230.             chsize(fileno(dbfp),i);
  3231. #else
  3232.             ftruncate(fileno(dbfp),i);
  3233. #endif /* COHERENT */
  3234.             x = 0;
  3235.             fseek(dbfp,i,0);
  3236.             break;
  3237.         }
  3238. #endif /* NOFTRUNCATE */
  3239.         debug(F101,"getslot record","",n);
  3240.         k = dbfld[db_FLAGS].off;
  3241.         j = dbfld[db_FLAGS].len;
  3242.         dbflags = hextoulong(&dbrec[k],j);
  3243.         debug(F001,"getslot dbflags","",dbflags);
  3244.         k = dbfld[db_MYPID].off;
  3245.         j = dbfld[db_MYPID].len;
  3246.         dbpid  = hextoulong(&dbrec[k],j);
  3247.         debug(F001,"getslot dbpid","",dbpid);
  3248.         k = dbfld[db_SADDR].off;
  3249.         j = dbfld[db_SADDR].len;
  3250.         dbip = hextoulong(&dbrec[k],j);
  3251.         debug(F001,"getslot dbip","",dbip);
  3253.         if (dbflags & DBF_INUSE) {      /* Remember last slot in use */
  3254.             x = 0;                      /* Make sure it's REALLY in use */
  3255.             if (dbpid == mypid && dbip == myip) { /* Check for PID == my PID */
  3256.                 x = 1;
  3257.                 debug(F101,"getslot record pid","",dbpid);
  3258.             } else {                    /* Or for stale PID */
  3259.                 x = zchkpid(dbpid);
  3260.                 debug(F101,"getslot zchkpid()","",x);
  3261.             }
  3262.             if (!x) {                   /* Bogus record */
  3263.                 x = freeslot(n);
  3264.                 debug(F101,"getslot stale record pid: freeslot()","",x);
  3265.                 if (x > -1 && !haveslot)
  3266.                   dbflags = 0;
  3267.             } else {                    /* It's really in use */
  3268.                 dblastused = i;
  3269.             }
  3270.         }
  3271.         if (!haveslot) {                /* If I don't have a slot yet */
  3272.             if (!(dbflags & DBF_INUSE)) {       /* Claim this one */
  3273.                 debug(F101,"getslot free slot", "", n);
  3274.                 haveslot = 1;
  3275.                 mydbseek = i;
  3276.                 mydbslot = n;           /* But keep going... */
  3277.             }
  3278.         }
  3279.     }
  3280.     /* Come here with i == seek pointer to first record after eof */
  3282.     if (!haveslot) {                    /* Found no free slot so add to end */
  3283.         debug(F101,"getslot new slot","",n);
  3284.         haveslot = 1;
  3285.         mydbseek = i;
  3286.         mydbslot = n;
  3287.     }
  3288.     ikdbopen = 1;                       /* OK to make database entries */
  3289.     debug(F101,"getslot records","",n);
  3290.     debug(F101,"getslot dblastused","",dblastused);
  3291.     debug(F101,"getslot i","",i);
  3293.     /* Trim stale records from end */
  3295. #ifndef NOFTRUNCATE
  3296.     if (i > dblastused+DB_RECL) {
  3297.         debug(F101,"getslot truncating at","",dblastused+DB_RECL);
  3298. #ifdef COHERENT
  3299.         x = chsize(fileno(dbfp),dblastused+DB_RECL);
  3300. #else
  3301.         x = ftruncate(fileno(dbfp),dblastused+DB_RECL);
  3302. #endif /* COHERENT */
  3303.         if (x < 0)                      /* (Not fatal) */
  3304.           debug(F101,"getslot ftruncate failed", "", errno);
  3305.     }
  3306. #endif /* NOFTRUNCATE */
  3308.     /* Initialize my record */
  3310.     if (initslot(mydbslot) < 0) {
  3311.         debug(F101,"getslot initslot() error","",n);
  3312.         ikdbopen = 0;
  3313.         goto xslot;
  3314.     }
  3315.     debug(F101,"getslot OK","",mydbslot);
  3316.     rc = mydbslot;                      /* OK return code */
  3318.   xslot:                                /* Unlock the database and return */
  3319.     if (unlink(lcknam) < 0) {
  3320.         debug(F111,"getslot lockfile removal failed",lcknam,errno);
  3321.         rc = -1;
  3322.     }
  3323.     return(rc);
  3324. }
  3325. #endif /* IKSDB */
  3326. #endif /* NOIKSD */