void clean_ctrlc() /* Cleanup CTRLC channel */ { struct { short status, count; int extra ; } iosb; unsigned int t_mask[2]; #if 0 status = SYS$QIOW(0,tchan, IO$_SETMODE,0,0,0,&orgttchar,12,0,0,0,0); if (!smg$enable) status = SYS$QIOW(0,tchan,(IO$_SETMODE+IO$M_OUTBAND),&iosb, 0,0,0,0,0,0,0,0); else { t_mask[0] = 0; t_mask[1] = 1 << 23; status = SYS$QIOW(0,tchan,(IO$_SETMODE+IO$M_OUTBAND),&iosb, 0,0,refresh,&t_mask,0,0,0,0); } #endif status = 1; }
/* * Run a command. The "cmd" is a pointer to a command string, or NULL if you * want to run a copy of DCL in the subjob (this is how the standard routine * LIB$SPAWN works. You have to do wierd stuff with the terminal on the way in * and the way out, because DCL does not want the channel to be in raw mode. */ int sys(char *cmd) { struct dsc$descriptor cdsc; struct dsc$descriptor *cdscp; long status; long substatus; long iosb[2]; status = SYS$QIOW(EFN, iochan, IO$_SETMODE, iosb, 0, 0, oldmode, sizeof(oldmode), 0, 0, 0, 0); if (status != SS$_NORMAL || (iosb[0] & 0xFFFF) != SS$_NORMAL) return FALSE; cdscp = NULL; /* Assume DCL. */ if (cmd != NULL) { /* Build descriptor. */ cdsc.dsc$a_pointer = cmd; cdsc.dsc$w_length = strlen(cmd); cdsc.dsc$b_dtype = DSC$K_DTYPE_T; cdsc.dsc$b_class = DSC$K_CLASS_S; cdscp = &cdsc; } status = LIB$SPAWN(cdscp, 0, 0, 0, 0, 0, &substatus, 0, 0, 0); if (status != SS$_NORMAL) substatus = status; status = SYS$QIOW(EFN, iochan, IO$_SETMODE, iosb, 0, 0, newmode, sizeof(newmode), 0, 0, 0, 0); if (status != SS$_NORMAL || (iosb[0] & 0xFFFF) != SS$_NORMAL) return FALSE; if ((substatus & STS$M_SUCCESS) == 0) /* Command failed. */ return FALSE; return TRUE; }
static int put ( io_channel chan, char *buffer, int length ) { int status; struct io_status iosb; status = SYS$QIOW ( 0, chan, IO$_WRITEVBLK, &iosb, 0, 0, buffer, length, 0, 0, 0, 0 ); if ( (status&1) == 1 ) status = iosb.status; return status; }
/* Decnet I/O routines. */ static int get ( io_channel chan, char *buffer, int maxlen, int *length ) { int status; struct io_status iosb; status = SYS$QIOW ( 0, chan, IO$_READVBLK, &iosb, 0, 0, buffer, maxlen, 0, 0, 0, 0 ); if ( (status&1) == 1 ) status = iosb.status; if ( (status&1) == 1 ) *length = iosb.count; return status; }
/* Get next line */ cip = 0; #if 1 if (smg$enable) { SMG$ERASE_LINE(&disp2_id, &i1, &i1); SMG$SET_CURSOR_ABS(&disp2_id,&i1,&i1); status = SMG$READ_COMPOSED_LINE(&keyb_id,&key_tab,&input_line, &prompt,&out_len,&disp2_id,0,0,0,0,0); /*Get next command */ cip = 1; } else status = SMG$READ_COMPOSED_LINE(&keyb_id,0,&input_line, &prompt,&out_len,0,0,0,0,0,0); /*Get next command */ #else printf("%s",prompt.dsc$a_pointer); out_len = read(0,command_line,254); out_len--; command_line[out_len]=0; if (strncmp(command_line,"exit",4)==0) return 0; #endif } } /* END of MAIN */ int help_command(int mask) /* HELP Purpose : call on-line help Output : contents of DFUHLP helplib. */ { unsigned int x,flag=1,tmp=0; #if 0 static char help[80]; $DESCRIPTOR(help_key ,help); $DESCRIPTOR(help_item, "helpkey"); $DESCRIPTOR(help_lib,"dfuhlp"); $DESCRIPTOR(item,"DFU "); $DESCRIPTOR(hlp_txt,"< DFU Help Screen >"); /* Check if a help item was entered */ if (cli$present(&help_item) == CLI$_PRESENT) cli$get_value(&help_item,&help_key,&help_key); else help_key.dsc$w_length=0; /* Add 'DFU ' to the help key */ help_key.dsc$w_length +=4; str$concat(&help_key,&item,&help_key); x = rows - 4; /* Reenable line editing... */ status = SYS$QIOW(0,tchan, IO$_SETMODE,0,0,0,&orgttchar,12,0,0,0,0); if (smg$enable) { SMG$CREATE_VIRTUAL_DISPLAY(&x, &colls, &help_id, 0 , 0, 0); SMG$LABEL_BORDER(&help_id, &hlp_txt, 0, 0,&SMG$M_BOLD); SMG$PASTE_VIRTUAL_DISPLAY(&help_id, &paste_id, &i2,&i2,0); status = SMG$PUT_HELP_TEXT(&help_id, &keyb_id, &help_key, &help_lib,0,0); SMG$UNPASTE_VIRTUAL_DISPLAY(&help_id, &paste_id); SMG$DELETE_VIRTUAL_DISPLAY(&help_id); } else status = lbr$output_help(lib$put_output,0,&help_key, &help_lib,&flag,lib$get_input); if (status != SS$_NORMAL) { sprintf(outbuf,"%%DFU-E-HELPERR, Error opening help library,"); put_disp(); singlemsg(0,status); } #endif return(1); } /*END help_command */
void reset_ctrl(void) /* Reset CTRLC/Y on the terminal channel */ { #if 0 int stat, func; struct { short status, count; int extra ; } iosb; unsigned int t_mask[2]; /* Disable the F6 key */ status = SYS$QIOW(0,tchan, IO$_SETMODE,0,0,0,&ttchar,12,0,0,0,0); ctrlc = 0; /* Enable CTRLC/Y trapping by setting CTRL C and Y as out-of-band chars*/ t_mask[0] = 0; t_mask[1] = 1 << 3; t_mask[1] += (1 << 25); status = SYS$QIOW(0,tchan,(IO$_SETMODE+IO$M_OUTBAND),&iosb, 0,0,astrtn,&t_mask,0,0,0,0); #endif }
PUBLIC BYTE GetAKey() { BYTE c; #ifdef SUN if ( TermMode == ORG_MODE ) { CurMode.c_iflag &= ~ICRNL; CurMode.c_lflag &= ~(ICANON | ECHO); CurMode.c_cc[VTIME] = 0; CurMode.c_cc[VMIN] = 1; ioctl( 0, TCSETS, &CurMode ); TermMode = GET_MODE; } else if ( TermMode == POLL_MODE ) { CurMode.c_cc[VTIME] = 0; CurMode.c_cc[VMIN] = 1; ioctl( 0, TCSETS, &CurMode ); TermMode = GET_MODE; } (void)read(0, &c, 1); #endif #ifdef MSC c = getch(); #endif #ifdef HELIOS if ( TermMode == ORG_MODE ) { RemoveAttribute(&CurAttributes,ConsoleEcho); AddAttribute(&CurAttributes,ConsoleRawInput); SetAttributes(InputStream,&CurAttributes); TermMode = GET_MODE; } (void)Read(InputStream, &c, 1, -1); #endif #ifdef VMS (void)SYS$QIOW(0, InputChan, (IO$_READVBLK | IO$M_NOECHO | IO$M_NOFILTR ), &iosb_desc, 0, 0, &c, 1, 0, 0L, 0, 0); #endif return(c); }
int rlSerial::writeChar(unsigned char uchar) { #ifdef RLUNIX int ret; if(fd == -1) return -1; if(trace == 1) printf("writeChar %d\n",(int)uchar); ret = write(fd,&uchar,1); if(ret < 0) return -1; //tcflush(fd, TCIOFLUSH); return ret; #endif #ifdef __VMS int status; IOSB iosb; status = SYS$QIOW(0,vms_channel,IO$_WRITEVBLK | IO$M_CANCTRLO | IO$M_NOFORMAT, &iosb,0,0,&uchar,1,0,0,0,0); if(status != SS$_NORMAL) return -1; return 1; #endif #ifdef RLWIN32 BOOL ret; unsigned long len; if(trace == 1) printf("writeChar %d\n",(int)uchar); ret = WriteFile( hdl, // handle to file to write to &uchar, // pointer to data to write to file 1, // number of bytes to write &len, // pointer to number of bytes written NULL // pointer to structure for overlapped I/O ); if(ret) return (int) len; return -1; #endif #ifdef RM3 return writeBlock(&uchar, 1); #endif }
int XEEnableCtrlY(void (*rtn)(int)) { #ifndef vms signal(SIGQUIT,rtn); /* CTRL-backslash */ return(1); #else /* vms */ int status; status = SYS$QIOW ( 0, /* Set characteristics */ comm_chan, /* Channel */ IO$_SETMODE|IO$M_CTRLYAST, /* Set ctrl_y */ comm_iosb, /* iosb address */ 0, 0, /* */ rtn, 0, /* AST routine and param */ CTRL_USER_MODE, 0, 0, 0 ); $CheckStatus(status); return (SS$_NORMAL); #endif /* vms */ }
/* * This function gets called just before we go back home to the command * interpreter. On VMS it puts the terminal back in a reasonable state. * Another no-operation on CPM. */ ttclose() { #if AMIGA Close(terminal); #endif #if VMS int status; int iosb[1]; ttflush(); status = SYS$QIOW(EFN, iochan, IO$_SETMODE, iosb, 0, 0, oldmode, sizeof(oldmode), 0, 0, 0, 0); if (status!=SS$_NORMAL || (iosb[0]&0xFFFF)!=SS$_NORMAL) exit(status); status = SYS$DASSGN(iochan); if (status != SS$_NORMAL) exit(status); #endif #if CPM #endif #if MSDOS && !__OS2__ int_restore(0x23); /* de-install control-break handler */ #endif #if BSDUNIX stty(1, &ostate); #if NONBLOCK fcntl(0,F_SETFL,oldstatus); #endif #endif #if linux || __OpenBSD__ || __APPLE__ tcsetattr(1, TCSADRAIN, &ostate); // return to original mode #endif #if NCURSES endwin(); #endif }
int __gnat_expect_poll (int *fd, int num_fd, int timeout, int *is_set) { int i, num, ready = 0; unsigned int status; int mbxchans [num_fd]; struct dsc$descriptor_s mbxname; struct io_status_block { short int condition; short int count; int dev; } iosb; char buf [256]; for (i = 0; i < num_fd; i++) is_set[i] = 0; for (i = 0; i < num_fd; i++) { /* Get name of the mailbox used in the pipe */ getname (fd [i], buf); /* Assign a channel to the mailbox */ if (strlen (buf) > 0) { mbxname.dsc$w_length = strlen (buf); mbxname.dsc$b_dtype = DSC$K_DTYPE_T; mbxname.dsc$b_class = DSC$K_CLASS_S; mbxname.dsc$a_pointer = buf; status = SYS$ASSIGN (&mbxname, &mbxchans[i], 0, 0, 0); if ((status & 1) != 1) { ready = -1; return ready; } } } num = timeout / 100; while (1) { for (i = 0; i < num_fd; i++) { if (mbxchans[i] > 0) { /* Peek in the mailbox to see if there's data */ status = SYS$QIOW (0, mbxchans[i], IO$_SENSEMODE|IO$M_READERCHECK, &iosb, 0, 0, 0, 0, 0, 0, 0, 0); if ((status & 1) != 1) { ready = -1; goto deassign; } if (iosb.count > 0) { is_set[i] = 1; ready = 1; goto deassign; } } } if (timeout > 0 && num == 0) { ready = 0; goto deassign; } usleep (100000); num--; } deassign: /* Deassign channels assigned above */ for (i = 0; i < num_fd; i++) { if (mbxchans[i] > 0) status = SYS$DASSGN (mbxchans[i]); } return ready; }
PUBLIC VOID SpPollkey() { BUFFER_DECLARATIONS; char c; #ifdef VMS struct CHARACTERISTICS { short Count; char ch; char res1; long res2; } Chars; #endif DEBUG(( "SP.POLLKEY" )); INIT_BUFFERS; #ifdef MSC if ( kbhit() ) { c = getch(); PUT_BYTE( SP_SUCCESS ); PUT_BYTE( c ); } else { PUT_BYTE( SP_ERROR ); } #endif #ifdef SUN if ( TermMode == ORG_MODE ) { CurMode.c_iflag &= ~ICRNL; CurMode.c_lflag &= ~(ICANON | ECHO); CurMode.c_cc[VTIME] = 1; CurMode.c_cc[VMIN] = 0; ioctl( 0, TCSETS, &CurMode ); TermMode = POLL_MODE; } else if ( TermMode == GET_MODE ) { CurMode.c_cc[VTIME] = 1; CurMode.c_cc[VMIN] = 0; ioctl( 0, TCSETS, &CurMode ); TermMode = POLL_MODE; } if ( read(0, &c, 1) == 0 ) { PUT_BYTE( SP_ERROR ); } else { PUT_BYTE( SP_SUCCESS ); PUT_BYTE( c ); } #endif #ifdef VMS (void)SYS$QIOW( 0, InputChan, (IO$_SENSEMODE | IO$M_TYPEAHDCNT ), &iosb_desc, 0, 0, &Chars, sizeof(struct CHARACTERISTICS), 0, 0, 0, 0 ) ; if ( Chars.Count > 0 ) { (void)SYS$QIOW( 0, InputChan, (IO$_READVBLK | IO$M_NOECHO | IO$M_NOFILTR ), &iosb_desc, 0, 0, &c, 1, 0, 0L, 0, 0 ); PUT_BYTE( SP_SUCCESS ); PUT_BYTE( c ); } else { PUT_BYTE( SP_ERROR ); } #endif #ifdef HELIOS if ( TermMode == ORG_MODE ) { RemoveAttribute(&CurAttributes,ConsoleEcho); AddAttribute(&CurAttributes,ConsoleRawInput); AddAttribute(&CurAttributes,ConsoleBreakInterrupt); SetAttributes(InputStream,&CurAttributes); TermMode = POLL_MODE; } if ( Read( InputStream, &c, 1, OneSec/10 ) == 1 ) { PUT_BYTE( SP_SUCCESS ); PUT_BYTE( c ); } else { PUT_BYTE( SP_ERROR ); } #endif REPLY; }
PUBLIC VOID SpGetkey() { #if (BOARD_ID == UDP) /* the udp version of iserver requires that the link is kept active, if it is inactive for X seconds the transputer will reset itself. Therefore this function polls the keyboard & sends an ACTIVE frame every X seconds to keep the transputer alive. */ BUFFER_DECLARATIONS; BYTE c; int timeval1,timeval2,finished; #ifdef VMS struct CHARACTERISTICS { short Count; char ch; char res1; long res2; } Chars; #endif DEBUG(( "SP.GETKEY {udp}" )); INIT_BUFFERS; finished = FALSE; time (&timeval1); while (!finished) { time (&timeval2); /* if 10 seconds elapsed, check link still active */ if ((timeval2-timeval1) >= QUIETTIMEOUT) { if (TestLink(TheLink) != SUCCEEDED) { finished = TRUE; PUT_BYTE( SP_ERROR ); break; } else { time (&timeval1); }; }; #ifdef MSC if (kbhit()) { c = getch(); PUT_BYTE( SP_SUCCESS ); PUT_BYTE( c ); finished = TRUE; }; #endif #ifdef SUN if ( TermMode == ORG_MODE ) { CurMode.c_iflag &= ~ICRNL; CurMode.c_lflag &= ~(ICANON | ECHO); CurMode.c_cc[VTIME] = 1; CurMode.c_cc[VMIN] = 0; ioctl( 0, TCSETS, &CurMode ); TermMode = POLL_MODE; } else { if ( TermMode == GET_MODE ) { CurMode.c_cc[VTIME] = 1; CurMode.c_cc[VMIN] = 0; ioctl( 0, TCSETS, &CurMode ); TermMode = POLL_MODE; }; }; if (read(0, &c, 1) != 0) { PUT_BYTE( SP_SUCCESS ); PUT_BYTE( c ); finished = TRUE; }; #endif #ifdef VMS (void)SYS$QIOW( 0, InputChan, (IO$_SENSEMODE | IO$M_TYPEAHDCNT ), &iosb_desc, 0, 0, &Chars, sizeof(struct CHARACTERISTICS), 0, 0, 0, 0 ) ; if (Chars.Count > 0) { (void)SYS$QIOW( 0, InputChan, (IO$_READVBLK | IO$M_NOECHO | IO$M_NOFILTR ), &iosb_desc, 0, 0, &c, 1, 0, 0L, 0, 0 ); PUT_BYTE( SP_SUCCESS ); PUT_BYTE( c ); finished = TRUE; }; #endif #ifdef HELIOS if ( TermMode == ORG_MODE ) { RemoveAttribute(&CurAttributes,ConsoleEcho); AddAttribute(&CurAttributes,ConsoleRawInput); AddAttribute(&CurAttributes,ConsoleBreakInterrupt); SetAttributes(InputStream,&CurAttributes); TermMode = POLL_MODE; } if ( Read( InputStream, &c, 1, OneSec/10 ) == 1 ) { PUT_BYTE( SP_SUCCESS ); PUT_BYTE( c ); finished = TRUE; }; #endif }; /* end of while */ DEBUG(("key was %c",c)); REPLY; #else BUFFER_DECLARATIONS; BYTE c; DEBUG(( "SP.GETKEY {non-udp}" )); INIT_BUFFERS; c = GetAKey(); DEBUG(("key was %c",c)); PUT_BYTE( SP_SUCCESS ); PUT_BYTE( c ); REPLY; #endif }
int rlSerial::writeBlock(const unsigned char *buf, int len) { #ifdef RLUNIX int ret; if(fd == -1) return -1; if(trace == 1) { printf("writeBlock:"); for(int i=0; i<len; i++) printf(" %d",(int) buf[i]); printf("\n"); } ret = write(fd,buf,len); //tcflush(fd, TCIOFLUSH); return ret; #endif #ifdef __VMS int status; IOSB iosb; status = SYS$QIOW(0,vms_channel,IO$_WRITEVBLK | IO$M_CANCTRLO | IO$M_NOFORMAT, &iosb,0,0,buf,len,0,0,0,0); if(status != SS$_NORMAL) return -1; return len; #endif #ifdef RLWIN32 BOOL ret; unsigned long retlen; if(trace == 1) { printf("writeBlock:"); for(int i=0; i<len; i++) printf(" %d",(int) buf[i]); printf("\n"); } retlen = len; ret = WriteFile( hdl, // handle to file to write to buf, // pointer to data to write to file len, // number of bytes to write &retlen, // pointer to number of bytes written NULL // pointer to structure for overlapped I/O ); if(ret) return (int) retlen; return -1; #endif #ifdef RM3 RmBytParmStruct PBlock; /* Parameterstruktur fr RmIO - Funktion */ RmIOStatusStruct DrvSts; /* Struktur der Rckgabewerte fr RmIO - Funktion */ unsigned char cByte; /* Rckgabewert von ibyte - Funktion */ int iStatus; /* Rckgabewert */ int i; /* Schleifenz�ler */ /**************************************************/ /* * Schreibparameter setzen */ PBlock.string = (char*)buf; PBlock.strlen = len; PBlock.buffer = 0; PBlock.timlen = 0; PBlock.status = 0; /****************************************************** * * * Toggle mode wird emuliert indem an dieser Stelle * * RTS-Signal gesetzt und sp�er wieder gel�cht wird * * * ******************************************************/ cByte = inbyte( com + 0x04u ); outbyte( com + 0x04, (unsigned char)(cByte | 0x02u) ); /* * Schreibvorgang einleiten */ iStatus = RmIO( BYT_WRITE_WAIT, (unsigned)device, (unsigned)unit, 0u, 0u, &DrvSts, &PBlock ); /****************************************************************** * * * 8ms warten.Bei der Aenderung der Uebertragungsgeschwindigkeit, * * sollte dieser Wert angepasst werden. Hier fuer 9600 * * * ******************************************************************/ RmPauseTask((RTS_TIME_WAIT*9600)/baudrate); /* * RTS-Signal l�chen */ outbyte( com + 0x04, (unsigned char)(cByte & 0xFDu) ); if( iStatus ) printf( "BYT_WRITE_WAIT (write block): Error status = %X\n", iStatus ); if( !iStatus ) return len; return -1; #endif }
int SOCKconnect(char *hostname, int port) { #if !defined(CMUIP) && !defined(NETLIB) struct sockaddr_in Server; struct hostent *HostPtr; int sockfd = 0; unsigned int ERRinet = -1; #ifdef _CRAY ERRinet = 0xFFFFFFFF; /* -1 doesn't sign extend on 64 bit machines */ #endif /*** Find the hostname address ***/ if (hostname == NULL || *hostname == '\0') return(ErrSocketNullHost); #ifdef DGUX Server.sin_addr = inet_addr(hostname); if (Server.sin_addr.s_addr == ERRinet) #else if ((Server.sin_addr.s_addr = inet_addr(hostname)) == ERRinet) #endif { if ((HostPtr = gethostbyname(hostname)) != NULL) { bzero((char *) &Server, sizeof(Server)); bcopy(HostPtr->h_addr, (char *) &Server.sin_addr, HostPtr->h_length); Server.sin_family = HostPtr->h_addrtype; } else return (ErrSocketGetHost); } else Server.sin_family = AF_INET; Server.sin_port = (unsigned short) htons(port); /*** Open the socket ***/ if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) return (ErrSocketCall); #ifndef UCX setsockopt(sockfd, SOL_SOCKET, ~SO_LINGER, 0, 0); #endif setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, 0, 0); setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, 0, 0); /*** Connect ***/ if (ControlCpressed) { /* Already interrupted */ return(ErrSocketInterrupted); } if (signal(SIGINT, controlcJmp) == SIG_ERR) perror("signal died:\n"), exit(-1); if (setjmp(Jmpenv)) { /* Note controlcJmp will reprime controlc and set flag*/ Debug("interruptable_connect triggered\r\n",NULL) return(ErrSocketInterrupted); } if (connect(sockfd, (struct sockaddr *) &Server, sizeof(Server)) < 0) { closenet(sockfd); reprimeControlc(); return (ErrSocketConnect); } reprimeControlc(); return(sockfd); #else /* !NETLIB && !CMUIP */ #ifdef NETLIB int status; static int iSock = 0; struct { long len; char *adr; } host_desc; #define NET_K_TCP 1 status = NET_ASSIGN (&iSock); if ((status & 1) == 0) return (ErrSocketCall); status = NET_BIND (&iSock, NET_K_TCP); if ((status & 1) == 0) return (ErrSocketCall); host_desc.adr = hostname; host_desc.len = strlen (host_desc.adr); status = TCP_CONNECT (&iSock, &host_desc, port); if ((status & 1) == 0) { NET_DEASSIGN (&iSock); if (status == SS$_REJECT || status == SS$_TIMEOUT) { if (status == SS$_REJECT) errno = ECONNREFUSED; else errno = ETIMEDOUT; return (ErrSocketConnect); } if (status == SS$_ENDOFFILE) return (ErrSocketGetHost); return (ErrSocketGetService); } return (iSock); #else /* ifdef NETLIB: assume CMUIP */ short channel; int status; struct { short status; short size; long xxx; } cmu_iosb; static struct {long l; char *a;} ip_dev = {12, "INET$DEVICE:"}; globalvalue NET$_CREF; /* Connection refused */ globalvalue NET$_FTO; /* Function timedout */ globalvalue NET$_DSNAMERR; /* Domain server name error */ status = SYS$ASSIGN (&ip_dev, &channel, 0, 0); if ((status & 1) == 0) return (ErrSocketCall); status = SYS$QIOW (0, channel, IO$_CREATE, &cmu_iosb, 0, 0, hostname, port, 0, 1, 0, 0); if ((status & 1) == 0 || (cmu_iosb.status & 1) == 0) { SYS$DASSGN (channel); if (cmu_iosb.status == SS$_ABORT || cmu_iosb.xxx == NET$_FTO) { if (cmu_iosb.xxx == NET$_CREF) errno = ECONNREFUSED; else errno = ETIMEDOUT; return(ErrSocketConnect); } if (cmu_iosb.xxx == NET$_DSNAMERR) return (ErrSocketGetHost); } return (channel); #endif #endif }
main(int argc, char *argv[]) /* MAIN Purpose : 1 Get privilege mask 2 Setup SMG environment unless no VT or DFU$NOSMG is set 3 Get and Parse command (syntax only) 4 Dispatch to correct subroutine Inputs : Command line (if specified through foreign command) Outputs : returns last status code to DCL in case of single command processing. In interactive mode always returns SS$_NORMAL. */ { const rms_eof=98938,smg$_eof=1213442; struct { short status, count; int extra ; } iosb; static char command_line[255], *e; unsigned int out_len,ret_len,prvmask; void reset_ctrl(), clean_ctrlc(), prev_screen(), next_screen(), dump_screen(), toggle_width() ; int smg_flag, x, y, i, ttype; int cursor_on = SMG$M_CURSOR_ON; $DESCRIPTOR(input_line , command_line); $DESCRIPTOR(prompt,"DFU> "); $DESCRIPTOR(terminal,"SYS$COMMAND"); $DESCRIPTOR(top_txt,"< DFU V2.2 (Freeware) >"); $DESCRIPTOR(status_txt,"Statistics"); $DESCRIPTOR(do_key,"DO"); $DESCRIPTOR(pf2,"PF2"); $DESCRIPTOR(pf4,"PF4"); $DESCRIPTOR(prev,"PREV_SCREEN"); $DESCRIPTOR(next,"NEXT_SCREEN"); $DESCRIPTOR(select,"SELECT"); $DESCRIPTOR(help,"HELP"); /* First find out how we got called ( by RUN, or a foreign command */ ret_len = 0; #if 0 status = lib$get_foreign(&input_line,0,&ret_len,0); #else status = 1; #if 0 strcpy(command_line,argv[1]); #endif #endif out_len = ret_len; smg$enable = TRUE; key_tab = 0; disp2_id = 0; cip = 0; setvbuf(stdout, NULL, _IONBF, 0); // need this to see i/o at all #if 0 smg$enable = FALSE; vms_mm = check_vms_mm(); #else /* Now create the SMG environment */ colls=80; rows=24; SMG$CREATE_PASTEBOARD(&paste_id, 0, &rows, &colls,&SMG$M_KEEP_CONTENTS,&ttype,0); if ((e = (char *) getenv("DFU$NOSMG")) && *e) smg$enable = FALSE; else { if (ttype != SMG$K_VTTERMTABLE) smg$enable = FALSE; if (ttype != SMG$K_VTTERMTABLE) SMG$DELETE_PASTEBOARD(&paste_id,&i0); } SMG$CREATE_VIRTUAL_KEYBOARD(&keyb_id,0,0,0,0); if (smg$enable) /* Setup key table */ { SMG$ERASE_PASTEBOARD(&paste_id, 0, 0, 0, 0, 0, 0); SMG$CREATE_KEY_TABLE(&key_tab); colls -=2; orig_colls = colls; smg_flag = SMG$M_KEY_NOECHO + SMG$M_KEY_TERMINATE; SMG$ADD_KEY_DEF(&key_tab,&do_key,0, &smg_flag, &do_key,0); SMG$ADD_KEY_DEF(&key_tab,&pf4,0, &smg_flag,&pf4,0); SMG$ADD_KEY_DEF(&key_tab,&prev,0, &smg_flag, &prev,0); SMG$ADD_KEY_DEF(&key_tab,&next,0, &smg_flag, &next,0); SMG$ADD_KEY_DEF(&key_tab,&pf2,0, &smg_flag, &help,0); SMG$ADD_KEY_DEF(&key_tab,&help,0, &smg_flag, &help,0); SMG$ADD_KEY_DEF(&key_tab,&select,0, &smg_flag, &select,0); SMG$CREATE_VIRTUAL_DISPLAY(&i500, &colls , &disp1_id, &SMG$M_BORDER, 0, 0); x = 508 - rows; y = rows - 7; SMG$CREATE_VIEWPORT(&disp1_id,&x,&i1,&y,&colls); SMG$CREATE_VIRTUAL_DISPLAY(&i2, &colls, &status_id, 0 , 0, 0); SMG$CREATE_VIRTUAL_DISPLAY(&i2, &colls, &disp2_id, 0 , 0, 0); SMG$SET_BROADCAST_TRAPPING(&paste_id,brdcst_ast,0); SMG$LABEL_BORDER(&disp1_id, &top_txt, 0, 0,&SMG$M_BOLD, 0, 0); SMG$LABEL_BORDER(&status_id, &status_txt, 0, 0,&SMG$M_BOLD, 0, 0); SMG$PASTE_VIRTUAL_DISPLAY(&disp1_id, &paste_id, &i2,&i2,0); x = rows - 4; SMG$PASTE_VIRTUAL_DISPLAY(&status_id, &paste_id, &x,&i2,0); x = rows - 1; SMG$PASTE_VIRTUAL_DISPLAY(&disp2_id, &paste_id, &x,&i2,0); x = 508 - rows; SMG$SET_CURSOR_ABS(&disp1_id,&x,&i1); SMG$SET_CURSOR_ABS(&disp2_id,&i1,&i1); SMG$BEGIN_PASTEBOARD_UPDATE(&paste_id); } #endif sprintf(outbuf,"\n Disk and File Utilities for OpenVMS DFU V2.2"); put_disp(); sprintf(outbuf," Freeware version"); put_disp(); sprintf(outbuf," Copyright © 1995 Digital Equipment Corporation\n"); put_disp(); if (smg$enable) { /* Enter additional info */ sprintf(outbuf," DFU functions are : \n"); put_disp(); sprintf(outbuf," DEFRAGMENT : Defragment files"); put_disp(); sprintf(outbuf," DELETE : Delete files by File-ID; delete directory (trees)"); put_disp(); sprintf(outbuf," DIRECTORY : Manipulate directories"); put_disp(); sprintf(outbuf," REPORT : Generate a complete disk report"); put_disp(); sprintf(outbuf," SEARCH : Fast file search"); put_disp(); sprintf(outbuf," SET : Modify file attributes"); put_disp(); sprintf(outbuf," UNDELETE : Recover deleted files"); put_disp(); sprintf(outbuf," VERIFY : Check and repair disk structure"); put_disp(); SMG$END_PASTEBOARD_UPDATE(&paste_id); } prvmask = 0; status = dfu_check_access(&prvmask); /*Get the privilege mask */ /* Setup terminal channel for control purposes; get the terminal chars */ status = SYS$ASSIGN(&terminal, &tchan, 0,0); status = SYS$QIOW(0,tchan, IO$_SENSEMODE,0,0,0,&orgttchar,12,0,0,0,0); for (i = 0; i < 3; i++) ttchar[i] = orgttchar[i]; ttchar[2] &= ~TT2$M_EDITING; /* Clear line edit bit */ clean_ctrlc(); /* Enable CTRL/W if needed */ if (ret_len==0) { if (smg$enable) status = SMG$READ_COMPOSED_LINE(&keyb_id,&key_tab,&input_line,&prompt, &out_len,&disp2_id,0,0,0,0,0); else status = SMG$READ_COMPOSED_LINE(&keyb_id,0,&input_line,&prompt, &out_len,0,0,0,0,0,0); } memcpy (command_line, input_line.dsc$a_pointer, input_line.dsc$w_length); cip = 1; /* Main loop starts here. Get a command and pasre it*/ for (;;) { /* loop forever until EXIT is entered */ if(status==smg$_eof) status = exit_command(prvmask); if ((status&1) != 1) goto endfor; if (out_len == 0) goto endfor; /* First catch special screen commands */ if (smg$enable) { status = strncmp(command_line, "PREV_SCREEN", 11); if (status == 0) { prev_screen(); goto endfor; } status = strncmp(command_line, "DO",2); if (status == 0) { status = spawn_command(prvmask); goto endfor; } status = strncmp(command_line, "PF4",3); if (status == 0) { dump_screen(); goto endfor; } status = strncmp(command_line, "NEXT_SCREEN", 11); if (status == 0) { next_screen(); goto endfor; } status = strncmp(command_line, "SELECT", 6); if (status == 0) { toggle_width(); goto endfor; } SMG$ERASE_DISPLAY(&disp1_id, 0, 0, 0, 0); SMG$ERASE_DISPLAY(&status_id, 0, 0, 0, 0); SMG$CHANGE_VIEWPORT(&disp1_id,&x,&i1,&y,&colls); SMG$SET_CURSOR_ABS(&disp1_id,&x,&i1); } /* Catch the CLI errors do avoid disrupting the SMG screen... */ #if 0 VAXC$ESTABLISH(prim_hand); #endif status = CLI$DCL_PARSE(&input_line,&dfu_tables,0 /* not yet lib$get_input*/,0,&prompt); // check added & before dfu_tables #if 0 VAXC$ESTABLISH(NULL); #endif if (status == CLI$_NOCOMD) singlemsg(0,status); if ((status & 1 ) != 1) goto endfor; else /* Now dispatch if no errors */ { reset_ctrl(); CLI$DISPATCH(prvmask); clean_ctrlc(); cip = 0; status = brdcst_ast(); if (smg$enable) SMG$SET_CURSOR_MODE(&paste_id, &cursor_on); } endfor: if (ret_len !=0) { /* Single command processing , so exit here */ status += 0x10000000; /* Do not echo the error on DCL level */ if (smg$enable) { if (colls != orig_colls) toggle_width(); SMG$SET_CURSOR_ABS(&disp2_id,&i2,&i1); } exit(status); } /* Get next line */ cip = 0; #if 1 if (smg$enable) { SMG$ERASE_LINE(&disp2_id, &i1, &i1); SMG$SET_CURSOR_ABS(&disp2_id,&i1,&i1); status = SMG$READ_COMPOSED_LINE(&keyb_id,&key_tab,&input_line, &prompt,&out_len,&disp2_id,0,0,0,0,0); /*Get next command */ cip = 1; } else status = SMG$READ_COMPOSED_LINE(&keyb_id,0,&input_line, &prompt,&out_len,0,0,0,0,0,0); /*Get next command */ #else printf("%s",prompt.dsc$a_pointer); out_len = read(0,command_line,254); out_len--; command_line[out_len]=0; if (strncmp(command_line,"exit",4)==0) return 0; #endif } } /* END of MAIN */
int vms_file_stats_name (const char *filename, long long *cdt, long *siz, char *rfo, int *ver) { #ifdef VMS struct FAB fab; struct NAM nam; unsigned long long create; FAT recattr; char ascnamebuff [256]; ATRDEF atrlst[] = { { ATR$S_CREDATE, ATR$C_CREDATE, &create }, { ATR$S_RECATTR, ATR$C_RECATTR, &recattr }, { ATR$S_ASCNAME, ATR$C_ASCNAME, &ascnamebuff }, { 0, 0, 0} }; FIBDEF fib; struct dsc$descriptor_fib fibdsc = {sizeof (fib), (void *) &fib}; struct IOSB iosb; long status; unsigned short chan; struct vstring file; struct dsc$descriptor_s filedsc = {NAM$C_MAXRSS, DSC$K_DTYPE_T, DSC$K_CLASS_S, (void *) file.string}; struct vstring device; struct dsc$descriptor_s devicedsc = {NAM$C_MAXRSS, DSC$K_DTYPE_T, DSC$K_CLASS_S, (void *) device.string}; struct vstring result; struct dsc$descriptor_s resultdsc = {NAM$C_MAXRSS, DSC$K_DTYPE_VT, DSC$K_CLASS_VS, (void *) result.string}; if (strcmp (filename, "<internal>") == 0 || strcmp (filename, "<built-in>") == 0) { if (cdt) *cdt = 0; if (siz) *siz = 0; if (rfo) *rfo = 0; if (ver) *ver = 0; return 0; } tryfile = to_vms_file_spec ((char *) filename); /* Allocate and initialize a FAB and NAM structures. */ fab = cc$rms_fab; nam = cc$rms_nam; nam.nam$l_esa = file.string; nam.nam$b_ess = NAM$C_MAXRSS; nam.nam$l_rsa = result.string; nam.nam$b_rss = NAM$C_MAXRSS; fab.fab$l_fna = tryfile; fab.fab$b_fns = strlen (tryfile); fab.fab$l_nam = &nam; /* Validate filespec syntax and device existence. */ status = SYS$PARSE (&fab, 0, 0); if ((status & 1) != 1) return 1; file.string[nam.nam$b_esl] = 0; /* Find matching filespec. */ status = SYS$SEARCH (&fab, 0, 0); if ((status & 1) != 1) return 1; file.string[nam.nam$b_esl] = 0; result.string[result.length=nam.nam$b_rsl] = 0; /* Get the device name and assign an IO channel. */ strncpy (device.string, nam.nam$l_dev, nam.nam$b_dev); devicedsc.dsc$w_length = nam.nam$b_dev; chan = 0; status = SYS$ASSIGN (&devicedsc, &chan, 0, 0, 0); if ((status & 1) != 1) return 1; /* Initialize the FIB and fill in the directory id field. */ memset (&fib, 0, sizeof (fib)); fib.fib$w_did[0] = nam.nam$w_did[0]; fib.fib$w_did[1] = nam.nam$w_did[1]; fib.fib$w_did[2] = nam.nam$w_did[2]; fib.fib$l_acctl = 0; fib.fib$l_wcc = 0; strcpy (file.string, (strrchr (result.string, ']') + 1)); filedsc.dsc$w_length = strlen (file.string); result.string[result.length = 0] = 0; /* Open and close the file to fill in the attributes. */ status = SYS$QIOW (0, chan, IO$_ACCESS|IO$M_ACCESS, &iosb, 0, 0, &fibdsc, &filedsc, &result.length, &resultdsc, &atrlst, 0); if ((status & 1) != 1) return 1; if ((iosb.status & 1) != 1) return 1; result.string[result.length] = 0; status = SYS$QIOW (0, chan, IO$_DEACCESS, &iosb, 0, 0, &fibdsc, 0, 0, 0, &atrlst, 0); if ((status & 1) != 1) return 1; if ((iosb.status & 1) != 1) return 1; /* Deassign the channel and exit. */ status = SYS$DASSGN (chan); if ((status & 1) != 1) return 1; if (cdt) *cdt = create; if (siz) *siz = (512 * 65536 * recattr.fat$w_efblkh) + (512 * (recattr.fat$w_efblkl - 1)) + recattr.fat$w_ffbyte; if (rfo) *rfo = recattr.fat$v_rtype; if (ver) *ver = strtol (strrchr (ascnamebuff, ';')+1, 0, 10); return 0; #else struct stat buff; struct tm *ts; if ((stat (filename, &buff)) != 0) return 1; if (cdt) { ts = localtime (&buff.st_mtime); *cdt = (long long) ((buff.st_mtim.tv_sec * VMS_GRANULARITY_FACTOR) + (buff.st_mtim.tv_nsec / 100)) + VMS_EPOCH_OFFSET; } if (siz) *siz = buff.st_size; if (rfo) *rfo = 2; /* Stream LF format. */ if (ver) *ver = 0; return 0; #endif }
$Id: vmstime.c,v 1.6 91/07/06 12:20:26 dhesi Exp $"; #endif /* This file was graciously supplied by Randal Barnes to support preservation of file timestamps under VAX/VMS. I claim no copyright on the contents of this file. I assume that neither do its authors. However, if you adapt this code for your own use, I recommend preserving author attributions. -- Rahul Dhesi 1991/07/04 */ /* * This module sets a VAX/VMS file's creation and revision date/time to a * specified date/time. * * Inputs Type Description * ------ ---- ----------- * path char * Name of file to be modified * date int Binary formatted date to be applied to the file * time int Binary formatted time to be applied to the file * * Outputs Type Description * ------- ---- ----------- * Modified file * * Randy Magnuson - (612) 542-5052 * Randal Barnes - (612) 542-5021 * Honeywell Inc. - Military Avionics Division * April 12, 1990 */ #include <stdio.h> #include <rms.h> #include <fibdef.h> #include <atrdef.h> #include <descrip.h> #include <iodef.h> #include <libdtdef.h> int setutime (char *path, unsigned int date, unsigned int time) { char EName [NAM$C_MAXRSS], /* Expanded String Area */ RName [NAM$C_MAXRSS], /* Resultant String Area */ date_str [50]; /* Holds intermediate ASCII date/time */ short iosb [4]; /* I/O status block for sys calls */ int status, /* Condition code for sys calls, etc. */ i, /* Temp index for looping thru arrays */ chan, /* Channel to device containing file */ Cdate [2], /* VMS binary time - creation date */ Rdate [2], /* VMS binary time - revision date */ datetimecontext = 0, /* Context for time conv. lib calls */ intime = LIB$K_INPUT_FORMAT, /* Constant for time lib calls */ intdate [2]; /* VMS binary time - temp */ struct FAB Fab; /* RMS File Access Block */ struct NAM Nam; /* RMS Name Block */ static struct fibdef Fib; /* RMS File Information Block */ struct atrdef Atr [] = /* File attribute struct */ { { sizeof (Cdate), ATR$C_CREDATE, &Cdate [0] }, /* Creation date */ { sizeof (Rdate), ATR$C_REVDATE, &Rdate [0] }, /* Revision date */ { 0, 0, 0 } }; struct dsc$descriptor devnam = /* Device name descriptor */ { 0, DSC$K_DTYPE_T, DSC$K_CLASS_S, &Nam.nam$t_dvi [1] }; struct dsc$descriptor FibDesc = /* File ID descriptor */ { sizeof (Fib), 0, 0, &Fib }; struct dsc$descriptor_s FileName = /* File name descriptor */ { 0, DSC$K_DTYPE_T, DSC$K_CLASS_S, 0 }; /* Time conversion format specification */ $DESCRIPTOR (datetimeformat, "|!Y4!MN0!D0|!H04!M0!S0!C2|"); /* String descriptor for intermediate date/time string */ $DESCRIPTOR (date_desc, date_str); /* * Fill out our File Access Block, Name Block, and Extended Attribute Block so * we can parse the file name. */ Fab = cc$rms_fab; Nam = cc$rms_nam; Fab.fab$l_fna = path; Fab.fab$b_fns = strlen (path); Fab.fab$l_nam = &Nam; Nam.nam$l_esa = &EName; Nam.nam$b_ess = sizeof (EName); Nam.nam$l_rsa = &RName; Nam.nam$b_rss = sizeof (RName); /* * Do a parse and search to fill out the NAM block. */ status = sys$parse(&Fab); if (!(status & 1)) return 0; status = sys$search(&Fab); if (!(status & 1)) return 0; /* * Open a channel to the device that the file resides on. */ devnam.dsc$w_length = Nam.nam$t_dvi [0]; status = SYS$ASSIGN (&devnam, &chan, 0, 0); if (!(status & 1)) return 0; /* * Initialize the FIB */ Fib.fib$r_acctl_overlay.fib$l_acctl = FIB$M_NORECORD; for (i = 0; i < 3; i++) { Fib.fib$r_fid_overlay.fib$w_fid [i] = Nam.nam$w_fid [i]; Fib.fib$r_did_overlay.fib$w_did [i] = Nam.nam$w_did [i]; } /* * Set up the file name descriptor for the QIO */ FileName.dsc$a_pointer = Nam.nam$l_name; FileName.dsc$w_length = Nam.nam$b_name + Nam.nam$b_type + Nam.nam$b_ver; /* * Use the IO$_ACCESS function to return info about the file. */ status = SYS$QIOW (0, chan, IO$_ACCESS, &iosb, 0, 0, &FibDesc, &FileName, 0, 0, 0, 0); if (!(status & 1)) return 0; status = iosb [0]; if (!(status & 1)) return 0; /* * Set up a date/time format that we can easily convert to - "YYMMDD HHMMSS" */ status = LIB$INIT_DATE_TIME_CONTEXT (&datetimecontext, &intime, &datetimeformat); if (!(status & 1)) return 0; /* * Convert the MS-DOS time ints to our ASCII format. */ date_desc.dsc$w_length = sprintf (date_str, "%04d%02d%02d %02d%02d%02d00", ((date >> 9) & 0x7f) + 1980, /* year */ (date >> 5) & 0x0f, /* month */ date & 0x1f, /* day */ (time >> 11)& 0x1f, /* hour */ (time >> 5) & 0x3f, /* min */ (time & 0x1f) * 2); /* sec */ /* * Convert our ASCII formatted date/time to VMS internal time format */ status = LIB$CONVERT_DATE_STRING (&date_desc, &intdate, &datetimecontext); if (!(status & 1)) return 0; /* * Fill in the creation date and revision date fields in the Extended Attribute * Block with the date and time from the zoo file. */ Cdate [0] = Rdate [0] = intdate [0]; Cdate [1] = Rdate [1] = intdate [1]; /* * Modify the file */ status = SYS$QIOW (0, chan, IO$_MODIFY, &iosb, 0, 0, &FibDesc, &FileName, 0, 0, &Atr, 0); if (!(status & 1)) return 0; status = iosb [0]; if (!(status & 1)) return 0; /* * Okee dokee. */ return 1; }
static int vms_file_stats_name (const char *dirname, const char *filename, long long *cdt, long *siz, char *rfo, int *ver) { char fullname[strlen (dirname) + strlen (filename) + 1]; #ifdef VMS struct FAB fab; struct NAM nam; unsigned long long create; FAT recattr; char ascnamebuff [256]; ATRDEF atrlst[] = { { ATR$S_CREDATE, ATR$C_CREDATE, &create }, { ATR$S_RECATTR, ATR$C_RECATTR, &recattr }, { ATR$S_ASCNAME, ATR$C_ASCNAME, &ascnamebuff }, { 0, 0, 0} }; FIBDEF fib; struct dsc$descriptor_fib fibdsc = {sizeof (fib), (void *) &fib}; struct IOSB iosb; long status; unsigned short chan; struct vstring file; struct dsc$descriptor_s filedsc = {NAM$C_MAXRSS, DSC$K_DTYPE_T, DSC$K_CLASS_S, (void *) file.string}; struct vstring device; struct dsc$descriptor_s devicedsc = {NAM$C_MAXRSS, DSC$K_DTYPE_T, DSC$K_CLASS_S, (void *) device.string}; struct vstring result; struct dsc$descriptor_s resultdsc = {NAM$C_MAXRSS, DSC$K_DTYPE_VT, DSC$K_CLASS_VS, (void *) result.string}; if (strcmp (filename, "<internal>") == 0 || strcmp (filename, "<built-in>") == 0) { if (cdt) *cdt = 0; if (siz) *siz = 0; if (rfo) *rfo = 0; if (ver) *ver = 0; return 0; } strcpy (fullname, dirname); strcat (fullname, filename); tryfile = to_vms_file_spec (fullname); /* Allocate and initialize a FAB and NAM structures. */ fab = cc$rms_fab; nam = cc$rms_nam; nam.nam$l_esa = file.string; nam.nam$b_ess = NAM$C_MAXRSS; nam.nam$l_rsa = result.string; nam.nam$b_rss = NAM$C_MAXRSS; fab.fab$l_fna = tryfile; fab.fab$b_fns = strlen (tryfile); fab.fab$l_nam = &nam; /* Validate filespec syntax and device existence. */ status = SYS$PARSE (&fab, 0, 0); if ((status & 1) != 1) return 1; file.string[nam.nam$b_esl] = 0; /* Find matching filespec. */ status = SYS$SEARCH (&fab, 0, 0); if ((status & 1) != 1) return 1; file.string[nam.nam$b_esl] = 0; result.string[result.length=nam.nam$b_rsl] = 0; /* Get the device name and assign an IO channel. */ strncpy (device.string, nam.nam$l_dev, nam.nam$b_dev); devicedsc.dsc$w_length = nam.nam$b_dev; chan = 0; status = SYS$ASSIGN (&devicedsc, &chan, 0, 0, 0); if ((status & 1) != 1) return 1; /* Initialize the FIB and fill in the directory id field. */ memset (&fib, 0, sizeof (fib)); fib.fib$w_did[0] = nam.nam$w_did[0]; fib.fib$w_did[1] = nam.nam$w_did[1]; fib.fib$w_did[2] = nam.nam$w_did[2]; fib.fib$l_acctl = 0; fib.fib$l_wcc = 0; strcpy (file.string, (strrchr (result.string, ']') + 1)); filedsc.dsc$w_length = strlen (file.string); result.string[result.length = 0] = 0; /* Open and close the file to fill in the attributes. */ status = SYS$QIOW (0, chan, IO$_ACCESS|IO$M_ACCESS, &iosb, 0, 0, &fibdsc, &filedsc, &result.length, &resultdsc, &atrlst, 0); if ((status & 1) != 1) return 1; if ((iosb.status & 1) != 1) return 1; result.string[result.length] = 0; status = SYS$QIOW (0, chan, IO$_DEACCESS, &iosb, 0, 0, &fibdsc, 0, 0, 0, &atrlst, 0); if ((status & 1) != 1) return 1; if ((iosb.status & 1) != 1) return 1; /* Deassign the channel and exit. */ status = SYS$DASSGN (chan); if ((status & 1) != 1) return 1; if (cdt) *cdt = create; if (siz) *siz = (512 * 65536 * recattr.fat$w_efblkh) + (512 * (recattr.fat$w_efblkl - 1)) + recattr.fat$w_ffbyte; if (rfo) *rfo = recattr.fat$v_rtype; if (ver) *ver = strtol (strrchr (ascnamebuff, ';') + 1, 0, 10); #else /* not VMS */ struct stat buff; struct tm *ts; long long gmtoff, secs, nsecs; strcpy (fullname, dirname); strcat (fullname, filename); if ((stat (fullname, &buff)) != 0) return 1; if (cdt) { ts = localtime (& buff.st_mtime); #ifdef HAVE_TM_GMTOFF gmtoff = ts->tm_gmtoff; #else { extern long timezone; if (ts->tm_isdst == 1) gmtoff = - (timezone - 3600); else gmtoff = - timezone; } #endif #ifdef HAVE_ST_MTIM_TV_SEC secs = buff.st_mtim.tv_sec; #else secs = buff.st_mtime; #endif #ifdef HAVE_ST_MTIM_TV_NSEC nsecs = buff.st_mtim.tv_nsec; #else nsecs = 0; #endif /* VMS timestamps are stored in local time to 100 nsec accuracy, but by experiment I found timestamps truncated to (at least) microseconds on an NFS mounted filesystem, hence the adjustment below. DBR. */ *cdt = ((secs + gmtoff) * VMS_GRANULARITY_FACTOR) + (nsecs / 1000 * 10) + VMS_EPOCH_OFFSET; } if (siz) *siz = buff.st_size; if (rfo) *rfo = 2; /* Stream LF format. */ /* Returning a file version of 0 is never correct for debug info, version 1 will be correct if file editing is done only on the Unix side. If editing is done on the VMS side, then its TBD. */ if (ver) *ver = 1; #endif /* VMS */ return 0; }
/* * This function is called once to set up the terminal device streams. * On VMS, it translates SYS$INPUT until it finds the terminal, then assigns * a channel to it and sets it raw. On CPM it is a no-op. */ ttopen() { #if AMIGA terminal = Open("RAW:1/1/639/199/MicroEmacs", NEW); #endif #if VMS struct dsc$descriptor idsc; struct dsc$descriptor odsc; char oname[40]; int iosb[2]; int status; odsc.dsc$a_pointer = "SYS$INPUT"; odsc.dsc$w_length = strlen(odsc.dsc$a_pointer); odsc.dsc$b_dtype = DSC$K_DTYPE_T; odsc.dsc$b_class = DSC$K_CLASS_S; idsc.dsc$b_dtype = DSC$K_DTYPE_T; idsc.dsc$b_class = DSC$K_CLASS_S; do { idsc.dsc$a_pointer = odsc.dsc$a_pointer; idsc.dsc$w_length = odsc.dsc$w_length; odsc.dsc$a_pointer = &oname[0]; odsc.dsc$w_length = sizeof(oname); status = LIB$SYS_TRNLOG(&idsc, &odsc.dsc$w_length, &odsc); if (status!=SS$_NORMAL && status!=SS$_NOTRAN) exit(status); if (oname[0] == 0x1B) { odsc.dsc$a_pointer += 4; odsc.dsc$w_length -= 4; } } while (status == SS$_NORMAL); status = SYS$ASSIGN(&odsc, &iochan, 0, 0); if (status != SS$_NORMAL) exit(status); status = SYS$QIOW(EFN, iochan, IO$_SENSEMODE, iosb, 0, 0, oldmode, sizeof(oldmode), 0, 0, 0, 0); if (status!=SS$_NORMAL || (iosb[0]&0xFFFF)!=SS$_NORMAL) exit(status); newmode[0] = oldmode[0]; newmode[1] = oldmode[1] | TT$M_PASSALL | TT$M_NOECHO; status = SYS$QIOW(EFN, iochan, IO$_SETMODE, iosb, 0, 0, newmode, sizeof(newmode), 0, 0, 0, 0); if (status!=SS$_NORMAL || (iosb[0]&0xFFFF)!=SS$_NORMAL) exit(status); #endif #if CPM #endif #if MSDOS && !__OS2__ /* Set control-break handler */ int_intercept(0x23,kbd_inthandler,128); #endif #if BSDUNIX /* Adjust output channel */ gtty(1, &ostate); /* save old state */ gtty(1, &nstate); /* get base of new state */ nstate.sg_flags |= RAW; nstate.sg_flags &= ~(ECHO|CRMOD); /* no echo for now... */ stty(1, &nstate); /* set mode */ #if NONBLOCK /* Set input to non-blocking */ oldstatus = fcntl(0,F_GETFL); fcntl(0,F_SETFL,oldstatus | FNDELAY); /* don't block on input */ #endif #endif #if linux || __OpenBSD__ || __APPLE__ /* Adjust output channel */ tcgetattr(1, &ostate); /* save old state */ tcgetattr(1, &nstate); /* get base of new state */ cfmakeraw(&nstate); tcsetattr(1, TCSADRAIN, &nstate); /* set mode */ #endif #if NCURSES initscr(); cbreak(); noecho(); nonl(); intrflush(stdscr, FALSE); keypad(stdscr, TRUE); #endif }
int rlSerial::readBlock(unsigned char *buf, int len, int timeout) { #ifdef RLUNIX int c, retlen; retlen = 0; for(int i=0; i<len; i++) { if(timeout >= 0) { if(select(timeout) == 0) break; // timeout } c = readChar(); if(c < 0) return c; buf[i] = (unsigned char) c; retlen = i+1; } if(retlen <= 0) return -1; return retlen; #endif #ifdef __VMS int status; int _timeout = 1; // second short iosb[4]; status = SYS$QIOW(0,vms_channel, IO$_READVBLK | IO$M_NOFILTR | IO$M_NOECHO | IO$M_TIMED, iosb,0,0,buf,len,_timeout,0,0,0); if(status != SS$_NORMAL) return -1; len=iosb[1]; if(iosb[2] != 0) { len++; buf[len] = iosb[2]; } return len; #endif #ifdef RLWIN32 BOOL ret; unsigned long retlen; if(timeout >= 0) select(timeout); ret = ReadFile( hdl, // handle of file to read buf, // pointer to buffer that receives data len, // number of bytes to read &retlen, // pointer to number of bytes read NULL // pointer to structure for data ); if(retlen > 0) { if(trace == 1) printf("readBlock retlen=%d\n",(int)retlen); return (int) retlen; } return -1; #endif #ifdef RM3 RmBytParmStruct PBlock; /* Parameterstruktur fr RmIO - Funktion */ RmIOStatusStruct DrvSts; /* Struktur der Rckgabewerte fr RmIO - Funktion */ int iStatus; /* Rckgabewert */ int i; /* Schleifenz�ler */ /**************************************************/ /* * Schreibparameter setzen */ PBlock.string = 0; PBlock.strlen = 0; PBlock.buffer = (char*)buf; PBlock.timlen = len; PBlock.status = 0; /* * Lesevorgang einleiten */ iStatus = RmIO( BYT_POLL_XBUF_WAIT, (unsigned)device, (unsigned)unit, 0u, 0u, &DrvSts, &PBlock ); if( iStatus ) printf( "BYT_POLL_XBUF_WAIT (set ucb): Error status = %X\n", iStatus ); if( !iStatus ) return len; return -1; #endif }
char * readpassphrase(const char *prompt, char *pbuf, size_t buflen, int flags) { static unsigned long keyboard_id, keytable_id = 0; unsigned long ctrl_mask, saved_ctrl_mask = 0; int timeout_secs = 0; int *timeout_ptr = NULL; unsigned long status = 0; unsigned short iosb[4]; unsigned short ttchan, result_len = 0, stdin_is_tty; $DESCRIPTOR(ttdsc, ""); $DESCRIPTOR(pbuf_dsc, ""); $DESCRIPTOR(prompt_dsc, ""); char *retval = NULL; char *myprompt = NULL; char input_fspec[MY_PASSWORD_LEN + 1]; if (pbuf == NULL || buflen == 0) { errno = EINVAL; return NULL; } bzero(pbuf, buflen); pbuf_dsc.dsc$a_pointer = pbuf; pbuf_dsc.dsc$w_length = buflen - 1; /* * If stdin is not a terminal and only reading from a terminal is allowed, we * stop here. */ stdin_is_tty = isatty(fileno(stdin)); if (stdin_is_tty != 1 && (flags & RPP_REQUIRE_TTY)) { errno = ENOTTY; return NULL; } /* * We need the file or device associated with stdin in VMS format. */ if (fgetname(stdin, input_fspec, 1)) { ttdsc.dsc$a_pointer = (char *)&input_fspec; ttdsc.dsc$w_length = strlen(input_fspec); } else { errno = EMFILE; return NULL; } /* * The prompt is expected to provide its own leading newline. */ myprompt = malloc(strlen(prompt) + 1); if (myprompt == NULL) { errno = ENOMEM; return NULL; } sprintf(myprompt, "\n%s", prompt); prompt_dsc.dsc$a_pointer = myprompt; prompt_dsc.dsc$w_length = strlen(myprompt); if (!(flags & RPP_ECHO_ON) && (stdin_is_tty)) { /* Disable Ctrl-T and Ctrl-Y */ ctrl_mask = LIB$M_CLI_CTRLT | LIB$M_CLI_CTRLY; status = LIB$DISABLE_CTRL(&ctrl_mask, &saved_ctrl_mask); if (!$VMS_STATUS_SUCCESS(status)) { errno = EVMSERR; vaxc$errno = status; free(myprompt); return NULL; } } /* * Unless timeouts are disabled, find out how long should we wait for input * before giving up. */ if (!(flags & RPP_TIMEOUT_OFF)) { unsigned long tmo_item = SYI$_LGI_PWD_TMO; status = LIB$GETSYI(&tmo_item, &timeout_secs); if (!$VMS_STATUS_SUCCESS(status)) timeout_secs = DEFAULT_TIMEOUT; timeout_ptr = &timeout_secs; } if (!(flags & RPP_ECHO_ON) && (stdin_is_tty)) { /* * If we are suppressing echoing, get a line of input with $QIOW. * Non-echoed lines are not stored for recall. (The same thing * could be done with SMG but would require maintenance of a virtual * display and pasteboard.) */ status = SYS$ASSIGN(&ttdsc, &ttchan, 0, 0, 0); if ($VMS_STATUS_SUCCESS(status)) { unsigned long qio_func = IO$_READPROMPT | IO$M_NOECHO | IO$M_PURGE; if (!(flags & RPP_TIMEOUT_OFF)) qio_func |= IO$M_TIMED; bzero(iosb, sizeof(iosb)); status = SYS$QIOW(0, (unsigned long) ttchan, qio_func, &iosb, 0, 0, pbuf, buflen - 1, timeout_secs, 0, myprompt, strlen(myprompt)); if ($VMS_STATUS_SUCCESS(status)) { status = iosb[0]; result_len = iosb[1]; /* bytes actually read */ } (void) SYS$DASSGN(ttchan); } } else { /* * We are not suppressing echoing because echoing has been explicitly * enabled and/or we are not reading from a terminal. In this case we * use SMG, which will store commands for recall. The virtual keyboard * and key table are static and will only be created if we haven't been * here before. */ status = SS$_NORMAL; if (keyboard_id == 0) { unsigned char recall_size = RECALL_SIZE; status = SMG$CREATE_VIRTUAL_KEYBOARD(&keyboard_id, &ttdsc, 0, 0, &recall_size); } if ($VMS_STATUS_SUCCESS(status) && keytable_id == 0) { status = SMG$CREATE_KEY_TABLE(&keytable_id); } if ($VMS_STATUS_SUCCESS(status)) { status = SMG$READ_COMPOSED_LINE(&keyboard_id, &keytable_id, &pbuf_dsc, &prompt_dsc, &result_len, 0, 0, 0, timeout_ptr); } } /* * Process return value from SYS$QIOW or SMG$READ_COMPOSED_LINE. */ switch (status) { case SS$_TIMEOUT: errno = ETIMEDOUT; break; case SMG$_EOF: if (result_len != 0) { status = SS$_NORMAL; } /* fall through */ default: if ($VMS_STATUS_SUCCESS(status)) { int i; if (flags & RPP_FORCELOWER) { for (i = 0; i < result_len; i++) pbuf[i] = tolower(pbuf[i]); } if (flags & RPP_FORCEUPPER) { for (i = 0; i < result_len; i++) pbuf[i] = toupper(pbuf[i]); } if (flags & RPP_SEVENBIT) { for (i = 0; i < result_len; i++) pbuf[i] &= 0x7f; } pbuf[result_len] = '\0'; retval = pbuf; } else { errno = EVMSERR; vaxc$errno = status; } } /* end switch */ free(myprompt); if (!(flags & RPP_ECHO_ON) && (stdin_is_tty)) { /* * Reenable previous control processing. */ status = LIB$ENABLE_CTRL(&saved_ctrl_mask); if (!$VMS_STATUS_SUCCESS(status)) { errno = EVMSERR; vaxc$errno = status; return NULL; } } return retval; } /* getpassphrase */