通讯/手机编程

开发平台：

Windows_Unix

ckuus7.c：源码内容

/* negotiations change if necessary. */
}
} else { /* They just said "set host" */
s = dftty; /* So go back to normal */
_local = dfloc; /* default tty, location, */
if (zz) {
setflow(); /* Maybe change flow control */
haveline = 1; /* (* is this right? *) */
/* why aren't we calling clsconnx()? */
#ifdef CKLOGDIAL
dologend();
#endif /* CKLOGDIAL */
return(success = 1);
}
}
#endif /* NETCONN */
}
/* Serial tty device, possibly modem, connection... */
if (xx == XYLINE /* SET LINE or SET PORT */
#ifdef CK_TAPI
|| xx == XYTAPI_LIN /* SET TAPI LINE */
#endif /* CK_TAPI */
) {
#ifdef OS2
/*
User can type:
COM1..COM8 = Regular COM port
1..8 = Synonym for COM1..COM8, is translated to COM1..COM8
_n = (n is a number) = open file handle
string = any text string = name of some other kind of device,
taken literally, as given.
*/
s = "Communication device name";
#ifdef CK_TAPI
if (TAPIAvail)
cktapiBuildLineTable(&tapilinetab, &_tapilinetab, &ntapiline);
if (!(tapilinetab && _tapilinetab && ntapiline > 0) &&
xx == XYTAPI_LIN ) {
slmsg = "TAPI device not configured";
printf("nNo TAPI Line Devices are configured for this systemn");
return(-9);
}
if (xx == XYTAPI_LIN) { /* Default (first) TAPI line */
s = "tapi"; /* (whatever it is) */
} else { /* Query the user */
#endif /* CK_TAPI */
/* Now parse optional switches and then device name */
confirmed = 0;
cmfdbi(&sw,_CMKEY,"Device name, or switch",
"","",npsltab,4,xxstring,psltab,&fl);
cmfdbi(&fl,_CMFLD,"",dftty,"",0,0,xxstring,NULL,NULL);
while (1) {
x = cmfdb(&sw);
debug(F101,"setlin cmfdb","",x);
if (x < 0)
if (x != -3)
return(x);
if (x == -3) {
if ((x = cmcfm()) < 0) {
return(x);
} else {
confirmed = 1;
break;
}
}
if (cmresult.fcode == _CMFLD) {
s = cmresult.sresult;
break;
} else if (cmresult.fcode == _CMKEY) {
switch (cmresult.nresult) {
case SL_CNX: /* /CONNECT */
cx = 1;
sx = 0;
break;
case SL_SRV: /* /SERVER */
cx = 0;
sx = 1;
break;
}
}
}
#ifdef CK_TAPI
}
#endif /* CK_TAPI */
debug(F110,"OS2 SET PORT s",s,0);
y = lookup(os2devtab,s,nos2dev,&x); /* Look up in keyword table */
debug(F101,"OS2 SET PORT x","",x);
debug(F101,"OS2 SET PORT y","",y);
if ((y > -1) && (x >= 0 && x < 8)) { /* User typed a digit 1..8 */
s = os2devtab[x+8].kwd; /* Substitite its real name */
#ifdef NT
xxtapi = 0;
#else /* NT */
xxslip = xxppp = 0;
#endif /* NT */
debug(F110,"OS2 SET PORT subst s",s,"");
#ifndef NT
} else if ((y >-1) && (x >= 16 && x < 24)) { /* SLIP access */
s = os2devtab[x-8].kwd; /* Substitite its real name */
debug(F110,"OS2 SET PORT SLIP subst s",s,"");
xxslip = 1;
xxppp = 0;
} else if ((y >-1) && (x >= 24 && x < 32)) { /* PPP access */
s = os2devtab[x-16].kwd; /* Substitite its real name */
debug(F110,"OS2 SET PORT PPP subst s",s,"");
xxppp = 1;
xxslip = 0;
if ((y = cmkey(os2ppptab,
nos2ppp,
"PPP driver interface",
"ppp0",
xxstring)
) < 0)
return(y);
debug(F101,"OS2 SET PORT PPP INTERFACE y","",y);
xxppp = (y % 10) + 1;
#endif /* NT */
} else if (*s == '_') { /* User used "_" prefix */
s++; /* Remove it */
/* Rest must be numeric */
debug(F110,"OS2 SET PORT HANDLE _subst s",s,0);
if (!rdigits(s)) {
slmsg = "Invalid file handle";
printf("?Invalid format for file handlen");
return(-9);
}
#ifdef NT
xxtapi = 0;
#else /* NT */
xxslip = xxppp = 0;
#endif /* NT */
} else { /* A normal COMx port or a string */
s = brstrip(s); /* Strip braces if any */
#ifdef NT
#ifdef CK_TAPI
/* Windows TAPI support - Look up in keyword table */
if (tapilinetab && _tapilinetab && ntapiline > 0) {
if (!ckstrcmp(s,"tapi",4,0)) {
/* Find out what the lowest numbered TAPI device is */
/* and use it as the default. */
int j = 9999, k = -1;
for (i = 0; i < ntapiline; i++) {
if (tapilinetab[i].kwval < j) {
j = tapilinetab[i].kwval;
k = i;
}
}
if (k >= 0)
s = _tapilinetab[k].kwd;
else
s = "";
if ((y = cmkey(_tapilinetab,ntapiline,
"TAPI device name",s,xxstring)) < 0)
return(y);
xxtapi = 1;
/* Get the non Underscored string */
for (i = 0; i < ntapiline; i++ ) {
if (tapilinetab[i].kwval == y) {
s = tapilinetab[i].kwd;
break;
}
}
} else
xxtapi = 0;
}
#endif /* CK_TAPI */
#else /* NT */
/* not OS/2 SLIP or PPP */
xxslip = xxppp = 0;
#endif /* NT */
}
strcpy(tmpbuf,s); /* Copy to a safe place */
s = tmpbuf;
if ((x = cmcfm()) < 0)
return(x);
#else /* !OS2 */
cmfdbi(&sw,_CMKEY,"Device name, or switch",
"","",npsltab,4,xxstring,psltab,&tx);
cmfdbi(&tx,_CMTXT,"",dftty,"",0,0,xxstring,NULL,NULL);
while (!confirmed) {
x = cmfdb(&sw);
debug(F101,"setlin cmfdb","",x);
if (x < 0)
if (x != -3)
return(x);
if (x == -3) {
if ((x = cmcfm()) < 0) {
return(x);
} else {
confirmed = 1;
break;
}
}
switch (cmresult.fcode) {
case _CMTXT:
strcpy(tmpbuf,cmresult.sresult);
s = tmpbuf;
debug(F110,"setlin CMTXT",tmpbuf,0);
confirmed = 1;
break;
case _CMKEY: /* Switch */
debug(F101,"setlin CMKEY",tmpbuf,cmresult.nresult);
switch (cmresult.nresult) {
case SL_CNX: /* /CONNECT */
cx = 1;
sx = 0;
break;
case SL_SRV: /* /SERVER */
cx = 0;
sx = 1;
break;
#ifdef VMS
case SL_SHR: /* /SHARE */
shr = 1;
break;
case SL_NSH: /* /NOSHARE */
shr = 0;
break;
#endif /* VMS */
}
continue;
default:
debug(F101,"setlin bad cmfdb result","",cmresult.fcode);
slmsg = "Internal error";
printf("?Internal parsing errorn");
return(-9);
}
}
#endif /* OS2 */
if (!confirmed)
if ((x = cmcfm()) < 0)
return(x);
debug(F101,"setlin confirmed mdmtyp","",mdmtyp);
if (clsconnx(1) < 0) /* Close the connection */
return(success = 0);
if (*s) { /* They gave a device name */
_local = -1; /* Let ttopen decide about it */
} else { /* They just said "set line" */
s = dftty; /* so go back to normal tty */
_local = dfloc; /* and mode. */
}
#ifdef VMS
{
extern int ok_to_share;
ok_to_share = shr;
}
#endif /* VMS */
#ifdef OS2 /* Must wait until after ttclos() */
#ifdef NT /* to change these settings */
#ifdef CK_TAPI
tttapi = xxtapi;
#endif /* CK_TAPI */
#else
ttslip = xxslip;
ttppp = xxppp;
#endif /* NT */
debug(F110,"OS2 SET PORT final s",s,"");
#endif /* OS2 */
}
success = 0;
if (mdmtyp > -1) { /* Serial connections... */
/* Open the new line */
if ((y = ttopen(s,&_local,mdmtyp,cdtimo)) > -1) {
cxtype = (mdmtyp > 0) ? CXT_MODEM : CXT_DIRECT;
#ifdef COMMENT
flow = cxflow[cxtype]; /* Set connection type and flow */
#else
setflow(); /* Only if autoflow()! */
#endif /* COMMENT */
success = 1;
#ifdef CK_TAPI
/* if the line is a tapi device, then we need to auto-execute */
/* SET MODEM TYPE TAPI - which we do the equivalent of here. */
if (xxtapi) {
extern int usermdm;
usermdm = 0;
initmdm(38); /* From ckudia.c n_TAPI == 38 */
}
#endif /* CK_TAPI */
} else {
#ifdef OS2ONLY
if (!strcmp(s,dftty)) /* Do not generate an error with dftty */
;
else if (y == -6 && ttslip) {
slmsg = "Can't access SLIP driver";
if (!quiet || cmdsrc() == 0)
printf("?Unable to access SLIP driver.n");
} else if (y == -6 && ttppp) {
if (!quiet || cmdsrc() == 0)
slmsg = "Can't access PPP driver";
printf("?Unable to access PPP driver (wrong interface?)n");
} else
#endif /* OS2ONLY */
if (y == -2) {
slmsg = "Timed out - no carrier";
if (!quiet || cmdsrc() == 0) {
printf("?Timed out, no carrier.n");
printf(
"Try SET CARRIER OFF and SET LINE again, or elsen");
printf("SET MODEM, SET LINE, and then DIAL.n");
}
} else if (y == -3) {
slmsg = "Access to lock denied";
if (!quiet || cmdsrc() == 0) {
#ifdef UNIX
printf(
"Sorry, write access to UUCP lockfile directory denied.n");
#ifndef NOHINTS
if (hints) {
printf("n*************************n");
printf(
"HINT (Use SET HINTS OFF to suppress future hints):n");
printf(
"Please read the installation instructions file, %sckuins.txt,n",
k_info_dir ? k_info_dir : ""
);
printf(
"or the UNIX appendix of the manual, "Using C-Kermit".n"
);
printf("*************************nn");
}
#endif /* NOHINTS */
#else
printf("Sorry, access to lock denied: %sn",s);
#endif /* UNIX */
}
} else if (y == -4) {
slmsg = "Access to device denied";
if (!quiet || cmdsrc() == 0) {
printf("Sorry, access to device denied: %sn",s);
#ifdef UNIX
#ifndef NOHINTS
if (hints) {
printf("n*************************n");
printf(
"HINT (Use SET HINTS OFF to suppress future hints):n");
printf(
"Please read the installation instructions file, %sckuins.txt,n",
k_info_dir ? k_info_dir : ""
);
printf(
"or the UNIX appendix of the manual, "Using C-Kermit".n"
);
printf("*************************nn");
}
#endif /* NOHINTS */
#endif /* UNIX */
}
} else if (y == -5) {
slmsg = "Device is in use or unavailable";
if (!quiet || cmdsrc() == 0)
#ifdef VMS
printf(
"Sorry, device is in use or otherwise unavailable: %sn",s);
#else
printf("Sorry, device is in use: %sn",s);
#endif /* VMS */
} else { /* Other error. */
slmsg = "Device open failed";
if (
#ifdef VMS
1
#else
errno
#endif /* VMS */
) {
int x; /* Find a safe, long buffer */
makestr(&tmpslmsg,ck_errstr());
slmsg = tmpslmsg;
#ifndef VMS
debug(F111,"setlin serial errno",slmsg,errno);
#endif /* VMS */
if (!quiet || cmdsrc() == 0) {
x = strlen(line) + 2; /* for the error message. */
if (LINBUFSIZ - x > 100) { /* Room for 100 chars */
tp = line + x;
sprintf(tp,"Sorry, can't open connection: %s",s);
perror(tp);
} else
printf("Sorry, can't open connection: %sn",s);
}
} else if (!quiet || cmdsrc() == 0)
printf("Sorry, can't open connection: %sn",s);
}
}
}
#ifdef NETCONN
else { /* mdmtyp < 0: Network connection */
char *p;
int i, n;
#ifndef NODIAL
debug(F101,"setlin mynet 3","",mynet);
debug(F101,"setlin nhcount","",nhcount);
if ((nhcount > 1) && !quiet && !backgrd) {
int k;
printf("%d entr%s found for "%s"%sn",
nhcount,
(nhcount == 1) ? "y" : "ies",
s,
(nhcount > 0) ? ":" : "."
);
for (i = 0; i < nhcount; i++) {
printf("%3d. %-12s => %-9s %s",
i+1,n_name,nh_p2[i],nh_p[i]);
for (k = 0; k < 4; k++) { /* Also list net-specific items */
if (nh_px[k][i]) /* free format... */
printf(" %s",nh_px[k][i]);
else
break;
}
printf("n");
}
}
if (nhcount == 0)
n = 1;
else
n = nhcount;
#else
n = 1;
nhcount = 0;
#endif /* NODIAL */
for (i = 0; i < n; i++) { /* Loop for each entry found */
#ifndef NODIAL
debug(F101,"setlin loop i","",i);
if (nhcount > 0) { /* If we found at least one entry... */
strcpy(line,nh_p[i]); /* Copy the current entry to line[] */
if (lookup(netcmd,nh_p2[i],nnets,&x) > -1) { /* Net type */
mynet = netcmd[x].kwval;
mdmtyp = 0 - mynet;
debug(F101,"setlin mynet 4","",mynet);
} else {
slmsg = "Network type not supported";
printf("Error - network type "%s" not supportedn",
nh_p2[i]
);
continue;
}
switch (mynet) { /* Net-specific things */
case NET_TCPB: { /* TCP/IP */
#ifdef TCPSOCKET
char *q;
int flag = 0;
/* Extract ":service", if any, from host string */
debug(F110,"setlin service 1",line,0);
for (q = line; (*q != '') && (*q != ':'); q++)
;
if (*q == ':') { *q++ = NUL; flag = 1; }
debug(F111,"setlin service 2",line,flag);
/* Get service, if any, from directory entry */
if (!*srvbuf) {
if (nh_px[0][i]) {
ckstrncpy(srvbuf,nh_px[0][i],SRVBUFSIZ);
debug(F110,"setlin service 3",srvbuf,0);
}
if (flag) {
ckstrncpy(srvbuf,q,SRVBUFSIZ);
debug(F110,"setlin service 4",srvbuf,0);
}
}
/* Save the hostname */
strcpy(hostname,line);
/* If we have a service, append to host name/address */
if (*srvbuf) {
strncat(line, ":", LINBUFSIZ);
strncat(line, srvbuf, LINBUFSIZ);
debug(F110,"setlin service 5",line,0);
}
#ifdef RLOGCODE
/* If no service given but command was RLOGIN */
else if (ttnproto == NP_RLOGIN) { /* add this... */
strncat(line, ":login",LINBUFSIZ);
debug(F110,"setlin service 6",line,0);
}
#ifdef CK_AUTHENTICATION
#ifdef CK_KERBEROS
else if (ttnproto == NP_K4LOGIN ||
ttnproto == NP_K5LOGIN) { /* add this... */
strncat(line, ":klogin",LINBUFSIZ);
debug(F110,"setlin service 7",line,0);
}
else if (ttnproto == NP_EK4LOGIN ||
ttnproto == NP_EK5LOGIN) { /* add this... */
strncat(line, ":eklogin",LINBUFSIZ);
debug(F110,"setlin service 8",line,0);
}
#endif /* CK_KERBEROS */
#endif /* CK_AUTHENTICATION */
#endif /* RLOGCODE */
else { /* Otherwise, add ":telnet". */
strncat(line, ":telnet", LINBUFSIZ);
debug(F110,"setlin service 9",line,0);
}
if (tmpusrid) if (tmpusrid[0]) {
ckstrncpy(uidbuf,tmpusrid,UIDBUFLEN);
makestr(&tmpusrid,NULL);
uidflag = 1;
}
/* Fifth field, if any, is user ID (for rlogin) */
if (nh_px[1][i] && !uidflag)
ckstrncpy(uidbuf,tmpusrid,UIDBUFLEN);
#ifdef RLOGCODE
if ((ttnproto == NP_RLOGIN
#ifdef CK_AUTHENTICATION
#ifdef CK_KERBEROS
|| ttnproto == NP_K4LOGIN || ttnproto == NP_EK4LOGIN
|| ttnproto == NP_K5LOGIN || ttnproto == NP_EK5LOGIN
#endif /* CK_KERBEROS */
#endif /* CK_AUTHENTICATION */
) && !uidbuf[0]) {
slmsg = "Username required";
printf("Username required for rloginn");
return(-9);
}
#endif /* RLOGCODE */
#endif /* TCPSOCKET */
break;
}
case NET_PIPE:
#ifdef NPIPE
if (!pipename[0]) { /* User didn't give a pipename */
if (nh_px[0][i]) { /* But directory entry has one */
if (strcmp(pipename,"\pipe\")) {
strcpy(pipename,"\pipe\");
strncat(srvbuf,nh_px[0][i],PIPENAML-6);
} else {
ckstrncpy(pipename,nh_px[0][i],PIPENAML);
}
debug(F110,"setlin pipeneme",pipename,0);
}
}
#endif /* NPIPE */
break;
case NET_SLAT:
#ifdef SUPERLAT
if (!slat_pwd[0]) { /* User didn't give a password */
if (nh_px[0][i]) { /* But directory entry has one */
ckstrncpy(slat_pwd,nh_px[0][i],18);
debug(F110,"setlin SuperLAT password",slat_pwd,0);
}
}
#endif /* SUPERLAT */
break;
case NET_SX25: /* X.25 keyword parameters */
case NET_IX25:
case NET_VX25: {
#ifdef ANYX25
int k; /* Cycle through the four fields */
for (k = 0; k < 4; k++) {
if (!nh_px[k][i]) /* Bail out if none left */
break;
if (!ckstrcmp(nh_px[k][i],"cug=",4,0)) {
closgr = atoi(nh_px[k][i]+4);
debug(F101,"X25 CUG","",closgr);
} else if (!ckstrcmp(nh_px[k][i],"cud=",4,0)) {
cudata = 1;
ckstrncpy(udata,nh_px[k][i]+4,MAXCUDATA);
debug(F110,"X25 CUD",cudata,0);
} else if (!ckstrcmp(nh_px[k][i],"rev=",4,0)) {
revcall = !ckstrcmp(nh_px[k][i]+4,"=on",3,0);
debug(F101,"X25 REV","",revcall);
#ifndef IBMX25
} else if (!ckstrcmp(nh_px[k][i],"pad=",4,0)) {
int x3par, x3val;
char *s1, *s2;
s1 = s2 = nh_px[k][i]+4; /* PAD parameters */
while (*s2) { /* Pick them apart */
if (*s2 == ':') {
*s2 = NUL;
x3par = atoi(s1);
s1 = ++s2;
continue;
} else if (*s2 == ',') {
*s2 = NUL;
x3val = atoi(s1);
s1 = ++s2;
debug(F111,"X25 PAD",x3par,x3val);
if (x3par > -1 &&
x3par <= MAXPADPARMS)
padparms[x3par] = x3val;
continue;
} else
s2++;
}
#endif /* IBMX25 */
}
}
#endif /* ANYX25 */
break;
}
default: /* Nothing special for other nets */
break;
}
} else { /* No directory entries found. */
strcpy(line,tmpbuf); /* Put this back... */
if (mynet == NET_TCPB) /* If the user gave a TCP service */
strcpy(hostname,line);
if (*srvbuf) { /* append it to host name/address */
strncat(line, ":", LINBUFSIZ);
strncat(line, srvbuf,LINBUFSIZ);
}
}
#endif /* NODIAL */
/*
Get here with host name/address and all net-specific
parameters set, ready to open the connection.
*/
mdmtyp = -mynet; /* This should have been done */
/* already but just in case ... */
debug(F110,"setlin net line[] before ttopen",line,0);
debug(F101,"setlin net mdmtyp before ttopen","",mdmtyp);
debug(F101,"setlin net ttnproto","",ttnproto);
#ifdef CK_AUTHENTICATION
if ((ttnproto == NP_TELNET || ttnproto == NP_KERMIT) &&
a_type > -1) {
if (!sl_auth_saved) {
int x;
for (x = 0; x < AUTHTYPLSTSZ; x++)
sl_auth_type_user[x] = auth_type_user[x];
sl_auth_saved = 1;
}
if (!sl_topt_a_s_saved) {
sl_topt_a_su = TELOPT_DEF_S_U_MODE(TELOPT_AUTHENTICATION);
sl_topt_a_s_saved = 1;
}
if (!sl_topt_a_c_saved) {
sl_topt_a_cm = TELOPT_DEF_C_ME_MODE(TELOPT_AUTHENTICATION);
sl_topt_a_c_saved = 1;
}
switch (a_type) {
case AUTHTYPE_AUTO:
auth_type_user[0] = AUTHTYPE_AUTO;
TELOPT_DEF_S_U_MODE(TELOPT_AUTHENTICATION) = TN_NG_RQ;
TELOPT_DEF_C_ME_MODE(TELOPT_AUTHENTICATION) = TN_NG_RQ;
break;
case AUTHTYPE_NULL:
auth_type_user[0] = AUTHTYPE_NULL;
TELOPT_DEF_S_U_MODE(TELOPT_AUTHENTICATION) = TN_NG_RF;
TELOPT_DEF_C_ME_MODE(TELOPT_AUTHENTICATION) = TN_NG_RF;
break;
#ifdef CK_SRP
case AUTHTYPE_SRP:
auth_type_user[0] = AUTHTYPE_SRP;
auth_type_user[1] = AUTHTYPE_NULL;
TELOPT_DEF_S_U_MODE(TELOPT_AUTHENTICATION) = TN_NG_MU;
TELOPT_DEF_C_ME_MODE(TELOPT_AUTHENTICATION) = TN_NG_MU;
break;
#endif /* CK_SRP */
#ifdef CK_SSL
case AUTHTYPE_SSL:
auth_type_user[0] = AUTHTYPE_SSL;
auth_type_user[1] = AUTHTYPE_NULL;
TELOPT_DEF_S_U_MODE(TELOPT_AUTHENTICATION) = TN_NG_MU;
TELOPT_DEF_C_ME_MODE(TELOPT_AUTHENTICATION) = TN_NG_MU;
break;
#endif /* CK_SSL */
#ifdef NT
case AUTHTYPE_NTLM:
auth_type_user[0] = AUTHTYPE_NTLM;
auth_type_user[1] = AUTHTYPE_NULL;
TELOPT_DEF_S_U_MODE(TELOPT_AUTHENTICATION) = TN_NG_MU;
TELOPT_DEF_C_ME_MODE(TELOPT_AUTHENTICATION) = TN_NG_MU;
break;
#endif /* NT */
#ifdef CK_KERBEROS
case AUTHTYPE_KERBEROS_V4:
auth_type_user[0] = AUTHTYPE_KERBEROS_V4;
auth_type_user[1] = AUTHTYPE_NULL;
TELOPT_DEF_S_U_MODE(TELOPT_AUTHENTICATION) = TN_NG_MU;
TELOPT_DEF_C_ME_MODE(TELOPT_AUTHENTICATION) = TN_NG_MU;
break;
case AUTHTYPE_KERBEROS_V5:
auth_type_user[0] = AUTHTYPE_KERBEROS_V5;
auth_type_user[1] = AUTHTYPE_NULL;
TELOPT_DEF_S_U_MODE(TELOPT_AUTHENTICATION) = TN_NG_MU;
TELOPT_DEF_C_ME_MODE(TELOPT_AUTHENTICATION) = TN_NG_MU;
break;
#endif /* CK_KERBEROS */
}
}
/*
If the user is going to require a Kerberos connection
of a particular type, let's make sure we have a valid TGT.
*/
slmsg = "Authentication failure";
if ((ttnproto == NP_TELNET || ttnproto == NP_KERMIT) &&
(line[0] == '*' &&
TELOPT_DEF_S_U_MODE(TELOPT_AUTHENTICATION) == TN_NG_MU ||
line[0] != '*' &&
TELOPT_DEF_C_ME_MODE(TELOPT_AUTHENTICATION) == TN_NG_MU)
) {
#ifdef CK_KERBEROS
if ( auth_type_user[0] == AUTHTYPE_KERBEROS_V4 ) {
extern int krb4_autoget;
if (!ck_krb4_is_installed()) {
printf(
"?Required authentication method (Kerberos 4) is not installedn"
);
slrestor();
return(success = 0);
}
#ifdef COMMENT
/* This code results in false failures when using */
/* kerberos to machines in realms other than the */
/* default since we don't know the realm of the */
/* other machine until perform the reverse DNS */
/* lookup. */
else if (line[0] != '*' && !ck_krb4_is_tgt_valid() &&
(!krb4_autoget ||
krb4_autoget && !ck_krb4_autoget_TGT(NULL))) {
printf(
"?Kerberos 4: Ticket Getting Ticket not valid.n"
);
slrestor();
return(success = 0);
}
#endif /* COMMENT */
} else if (auth_type_user[0] == AUTHTYPE_KERBEROS_V5) {
extern int krb5_autoget;
if (!ck_krb5_is_installed()) {
printf(
"?Required authentication method (Kerberos 5) is not installedn"
);
slrestor();
return(success = 0);
}
#ifdef COMMENT
/* This code results in false failures when using */
/* kerberos to machines in realms other than the */
/* default since we don't know the realm of the */
/* other machine until perform the reverse DNS */
/* lookup. */
else if (line[0] != '*' && !ck_krb5_is_tgt_valid() &&
(!krb5_autoget ||
krb5_autoget && !ck_krb5_autoget_TGT(NULL))) {
printf(
"?Kerberos 5: Ticket Getting Ticket not valid.n"
);
slrestor();
return(success = 0);
}
#endif /* COMMENT */
}
#endif /* CK_KERBEROS */
#ifdef NT
if (auth_type_user[0] == AUTHTYPE_NTLM) {
if (!ck_ntlm_is_installed()) {
printf(
"?Required authentication method (NTLM) is not installedn"
);
slrestor();
return(success = 0);
} else if (line[0] != '*' && !ck_ntlm_is_valid()) {
printf("?NTLM: Credentials are unavailable.n");
slrestor();
return(success = 0);
}
}
#endif /* NT */
#ifdef CK_SSL
if (auth_type_user[0] == AUTHTYPE_SSL) {
if (!ck_ssleay_is_installed()) {
printf(
"?Required authentication method (SSL) is not installedn"
);
slrestor();
return(success = 0);
}
}
#endif /* CK_SSL */
#ifdef CK_SRP
if (auth_type_user[0] == AUTHTYPE_SRP) {
if (!ck_srp_is_installed()) {
printf(
"?Required authentication method (SRP) is not installedn"
);
slrestor();
return(success = 0);
}
}
#endif /* CK_SRP */
}
#endif /* CK_AUTHENTICATION */
#ifdef CK_ENCRYPTION
if ((ttnproto == NP_TELNET || ttnproto == NP_KERMIT) &&
e_type > -1) {
if (!sl_cx_saved) {
sl_cx_type = cx_type;
sl_cx_saved = 1;
}
if (!sl_topt_e_s_saved) {
sl_topt_e_su = TELOPT_DEF_S_U_MODE(TELOPT_ENCRYPTION);
sl_topt_e_sm = TELOPT_DEF_S_ME_MODE(TELOPT_ENCRYPTION);
sl_topt_e_s_saved = 1;
}
if (!sl_topt_e_c_saved) {
sl_topt_e_cu = TELOPT_DEF_C_U_MODE(TELOPT_ENCRYPTION);
sl_topt_e_cm = TELOPT_DEF_C_ME_MODE(TELOPT_ENCRYPTION);
sl_topt_e_c_saved = 1;
}
cx_type = e_type;
if (cx_type == CX_AUTO) {
TELOPT_DEF_S_U_MODE(TELOPT_ENCRYPTION) = TN_NG_RQ;
TELOPT_DEF_S_ME_MODE(TELOPT_ENCRYPTION) = TN_NG_RQ;
TELOPT_DEF_C_U_MODE(TELOPT_ENCRYPTION) = TN_NG_RQ;
TELOPT_DEF_C_ME_MODE(TELOPT_ENCRYPTION) = TN_NG_RQ;
} else if (cx_type == CX_NONE) {
TELOPT_DEF_S_U_MODE(TELOPT_ENCRYPTION) = TN_NG_RF;
TELOPT_DEF_S_ME_MODE(TELOPT_ENCRYPTION) = TN_NG_RF;
TELOPT_DEF_C_U_MODE(TELOPT_ENCRYPTION) = TN_NG_RF;
TELOPT_DEF_C_ME_MODE(TELOPT_ENCRYPTION) = TN_NG_RF;
} else {
TELOPT_DEF_S_U_MODE(TELOPT_ENCRYPTION) = TN_NG_MU;
TELOPT_DEF_S_ME_MODE(TELOPT_ENCRYPTION) = TN_NG_MU;
TELOPT_DEF_C_U_MODE(TELOPT_ENCRYPTION) = TN_NG_MU;
TELOPT_DEF_C_ME_MODE(TELOPT_ENCRYPTION) = TN_NG_MU;
}
}
if (ttnproto == NP_EK4LOGIN || ttnproto == NP_EK5LOGIN ||
(ttnproto == NP_TELNET || ttnproto == NP_KERMIT) &&
((line[0] == '*' &&
TELOPT_DEF_S_U_MODE(TELOPT_ENCRYPTION) == TN_NG_MU &&
TELOPT_DEF_S_ME_MODE(TELOPT_ENCRYPTION) == TN_NG_MU) ||
(line[0] != '*' &&
TELOPT_DEF_C_U_MODE(TELOPT_ENCRYPTION) == TN_NG_MU &&
TELOPT_DEF_C_ME_MODE(TELOPT_ENCRYPTION) == TN_NG_MU))
) {
if (!ck_crypt_is_installed()) {
slmsg = "Encryption failure";
printf("?Required Encryption methods are not installedn");
slrestor();
return(success = 0);
}
}
#endif /* CK_ENCRYPTION */
#ifdef RLOGCODE
#ifdef CK_KERBEROS
#ifdef KRB4
if (ttnproto == NP_K4LOGIN || ttnproto == NP_EK4LOGIN) {
extern int krb4_autoget;
char tgt[256];
char * realm;
/* this is fine except for one huge problem */
/* we don't have the full hostname at this point */
/* so we really need to perform a DNS lookup before */
/* calling ttopen(). */
realm = ck_krb4_realmofhost(ckgetfqhostname(hostname));
sprintf(tgt,"krbtgt.%s@%s",realm,realm);
if (!ck_krb4_is_installed()) {
printf(
"?Required authentication method (Kerberos 4) is not installedn"
);
slrestor();
return(success = 0);
} else {
if ((ck_krb4_tkt_isvalid(tgt) <= 0) &&
(!krb4_autoget ||
krb4_autoget && !ck_krb4_autoget_TGT(realm))) {
printf(
"?Kerberos 4: Ticket Getting Ticket not valid.n");
slrestor();
return(success = 0);
}
}
}
#endif /* KRB4 */
#ifdef KRB5
if (ttnproto == NP_K5LOGIN || ttnproto == NP_EK5LOGIN) {
extern int krb5_autoget;
char tgt[256];
char * realm;
/* this is fine except for one huge problem */
/* we don't have the full hostname at this point */
/* so we really need to perform a DNS lookup before */
/* calling ttopen(). */
realm = ck_krb5_realmofhost(ckgetfqhostname(hostname));
sprintf(tgt,"krbtgt/%s@%s",realm,realm);
if (!ck_krb5_is_installed()) {
printf(
"?Required authentication method (Kerberos 5) is not installedn"
);
slrestor();
return(success = 0);
} else if (!((ck_krb5_tkt_isvalid(NULL,tgt) > 0) ||
ck_krb5_is_tgt_valid()) &&
(!krb5_autoget ||
krb5_autoget && !ck_krb5_autoget_TGT(realm))) {
printf("?Kerberos 5: Ticket Getting Ticket not valid.n");
slrestor();
return(success = 0);
}
}
#endif /* KRB5 */
#endif /* CK_KERBEROS */
#endif /* RLOGCODE */
#ifdef NETCONN
#ifndef NOSPL
if (tmpstring) {
if (tmpstring[0]) {
ckstrncpy(pwbuf,tmpstring,PWBUFL+1);
pwflg = 1;
pwcrypt = 0;
} else
pwflg = 0;
makestr(&tmpstring,NULL);
}
#ifdef RLOGCODE
if (tmpusrid) if (tmpusrid[0]) {
if (!sl_uid_saved) {
ckstrncpy(sl_uidbuf,uidbuf,UIDBUFLEN);
sl_uid_saved = 1;
}
ckstrncpy(uidbuf,tmpusrid,UIDBUFLEN);
makestr(&tmpusrid,NULL);
uidflag = 1;
}
#endif /* RLOGCODE */
#endif /* NOSPL */
#endif /* NETCONN */
#ifdef TNCODE
if (!sl_tn_saved) {
sl_tn_wait = tn_wait_flg;
sl_tn_saved = 1;
}
tn_wait_flg = wait;
#endif /* TNCODE */
/* Try to open */
if ((y = ttopen(line, &_local, mdmtyp, 0 )) < 0) {
slrestor();
slmsg = "Network connection failure";
#ifdef VMS
if (hints && !cmdsrc() && ttnproto == NP_RLOGIN) {
slmsg = "RLOGIN failure";
printf("*************************n");
printf("Hint: The RLOGIN port is privileged in VMS.n");
printf("(Use SET HINTS OFF to suppress future hints.)n");
printf("*************************n");
}
#else /* Not VMS... */
if (errno) {
int x;
debug(F111,"set host line, errno","",errno);
makestr(&tmpslmsg,ck_errstr());
slmsg = tmpslmsg;
x = strlen(line) + 2;
if (LINBUFSIZ - x > 100) {
tp = line + x;
#ifdef OS2
printf("Can't connect to %sn",line);
#else /* OS2 */
#ifdef COMMENT
sprintf(tp,"Can't connect to %s",line);
perror(tp);
#endif /* COMMENT */
#ifdef UNIX
if (hints && !cmdsrc() && ttnproto == NP_RLOGIN) {
slmsg = "RLOGIN failure";
printf("*************************n");
printf(
"Hint: The RLOGIN port is privileged in UNIX.n");
printf(
"(Use SET HINTS OFF to suppress future hints.)n");
printf("*************************n");
}
#endif /* UNIX */
#endif /* OS2 */
} else printf("Can't connect to %sn",line);
} else
#endif /* VMS */
printf("Can't open connection to %sn",line);
continue;
} else {
success = 1;
switch (mynet) {
case NET_TCPA:
case NET_TCPB:
cxtype = CXT_TCPIP;
break;
case NET_SLAT:
cxtype = CXT_LAT;
break;
case NET_SX25:
case NET_IX25:
case NET_HX25:
case NET_VX25:
cxtype = CXT_X25;
break;
case NET_BIOS:
cxtype = CXT_NETBIOS;
break;
case NET_FILE:
case NET_PIPE:
case NET_CMD:
case NET_DLL:
case NET_PTY:
cxtype = CXT_PIPE;
break;
default:
cxtype = CXT_PIPE;
break;
}
break;
}
} /* for-loop */
s = line;
} /* network connection */
#endif /* NETCONN */
/*
NOTE:
The following will fail if Kermit is running as a daemon with no
controlling tty. Needs research.
*/
if (!success) {
local = dfloc; /* Go back to normal */
#ifndef MAC
strcpy(ttname,dftty); /* Restore default tty name */
#endif /* MAC */
speed = ttgspd();
network = 0; /* No network connection active */
haveline = 0;
if (mdmtyp < 0) { /* Switching from net to async? */
if (mdmsav > -1) /* Restore modem type from last */
mdmtyp = mdmsav; /* SET MODEM command, if any. */
else
mdmtyp = 0;
mdmsav = -1;
}
return(0); /* Return failure */
}
if (_local > -1) local = _local; /* Opened ok, set local/remote. */
slmsg = NULL;
network = (mdmtyp < 0); /* Remember connection type. */
strcpy(ttname,s); /* Copy name into real place. */
debug(F110,"setlin ok",ttname,0);
debug(F101,"setlin network","",network);
if (!network)
speed = ttgspd(); /* Get the current speed. */
debug(F101,"setlin local","",local);
#ifdef NETCONN
if (network) {
debug(F101,"setlin mynet","",mynet);
#ifndef NOXFER
/* Force prefixing of 255 on TCP/IP connections... */
if (mynet == NET_TCPB) {
debug(F101,"setlin reliable A","",reliable);
#ifdef CK_SPEED
ctlp[(unsigned)255] = 1;
#endif /* CK_SPEED */
if (reliable != SET_OFF || !setreliable)
reliable = SET_ON; /* Transport is reliable end to end */
debug(F101,"setlin reliable B","",reliable);
} else if (mynet == NET_SX25 ||
mynet == NET_VX25 ||
mynet == NET_IX25 ||
mynet == NET_HX25) {
duplex = 1; /* Local echo for X.25 */
if (reliable != SET_OFF || !setreliable)
reliable = SET_ON; /* Transport is reliable end to end */
}
#endif /* NOXFER */
}
#endif /* NETCONN */
#ifndef NOXFER
debug(F101,"setlin reliable","",reliable);
#endif /* NOXFER */
#ifdef OS2
if (mdmtyp <= 0) /* Network or Direct Connection */
DialerSend(OPT_KERMIT_CONNECT, 0);
#endif /* OS2 */
setflow(); /* Set appropriate flow control */
haveline = 1;
#ifdef CKLOGDIAL
#ifdef NETCONN
if (network) /* Start connection log record */
dolognet();
else
#endif /* NETCONN */
dologline();
#endif /* CKLOGDIAL */
#ifndef NOSPL
if (local) {
if (nmac) { /* Any macros defined? */
int k; /* Yes */
k = mlook(mactab,"on_open",nmac); /* Look this up */
if (k >= 0) { /* If found, */
if (dodo(k,ttname,0) > -1) /* set it up, */
parser(1); /* and execute it */
}
}
}
#endif /* NOSPL */
if (local && (cx || sx)) { /* /CONNECT or /SERVER switch given */
extern int carrier;
if (xx == XYLINE && carrier != CAR_OFF) { /* on serial connection... */
/* Open() turns on DTR -- wait up to a second for CD to come up */
int i, x;
for (i = 0; i < 10; i++) { /* WAIT 1 CD... */
x = ttgmdm();
if (x < 0 || x & BM_DCD)
break;
msleep(100);
}
}
if (cx) { /* /CONNECT */
success = doconect(0);
#ifdef CKLOGDIAL
if (ttchk() < 0)
dologend();
#endif /* CKLOGDIAL */
return(success);
#ifndef NOXFER
} else if (sx) { /* /SERVER */
sstate = 'x';
#ifdef MAC
what = W_RECV;
scrcreate();
#endif /* MAC */
if (local) displa = 1;
#ifdef AMIGA
reqoff(); /* No DOS requestors while server */
#endif /* AMIGA */
#endif /* NOXFER */
}
}
return(success = 1);
}
#endif /* NOLOCAL */
#ifdef CKCHANNELIO
/*
C-Library based file-i/o package for scripts. This should be portable to
all C-Kermit versions since it uses the same APIs we have always used for
processing command files. The entire channel i/o package is contained
herein, apart from some keyword table entries in the main keyword table
and the help text in the HELP command module.
On platforms like VMS and VOS, this package handles only UNIX-style
stream files. If desired, it can be replaced for those platforms by
<#>ifdef'ing out this code and adding the equivalent replacement routines
to the ck?fio.c module, e.g. for RMS-based file i/o in ckvfio.c.
*/
/* Define NOSTAT if the <#>include causes trouble. */
#ifndef NOSTAT
#ifdef VMS
#ifdef VAXC /* As it does in VAX C */
#define NOSTAT
#endif /* VAXC */
#endif /* VMS */
#endif /* NOSTAT */
#ifndef NOSTAT
#include <sys/stat.h>
#endif /* NOSTAT */
#ifdef NLCHAR
static int z_lt = 1; /* Length of line terminator */
#else
static int z_lt = 2;
#endif /* NLCHAR */
struct ckz_file { /* C-Kermit file struct */
FILE * z_fp; /* Includes the C-Lib file struct */
unsigned int z_flags; /* Plus C-Kermit mode flags, */
long z_nline; /* current line number if known, */
char z_name[CKMAXPATH+2]; /* and the file's name. */
};
static struct ckz_file * z_file = NULL; /* Array of C-Kermit file structs */
static int z_inited = 0; /* Flag for array initialized */
int z_maxchan = Z_MAXCHAN; /* Max number of C-Kermit channels */
int z_openmax = CKMAXOPEN; /* Max number of open files overall */
int z_nopen = 0; /* How many channels presently open */
int z_error = 0; /* Most recent error */
int z_filcount = -1; /* Most recent FILE COUNT result */
#define RD_LINE 0 /* FILE READ options */
#define RD_CHAR 1
#define RD_SIZE 2
#define WR_LINE RD_LINE /* FILE WRITE options */
#define WR_CHAR RD_CHAR
#define WR_SIZE RD_SIZE
#define WR_STRI 3
#define WR_LPAD 4
#define WR_RPAD 5
#ifdef UNIX
extern int ckmaxfiles; /* Filled in by sysinit(). */
#endif /* UNIX */
/* See ckcker.h for error numbers */
/* See ckcdeb.h for Z_MAXCHAN and CKMAXOPEN definitions */
/* NOTE: For VMS we might be able to fill in ckmaxfiles */
/* from FILLM and CHANNELCNT -- find out about these... */
static char * fopnargs[] = { /* Mode combinations for fopen() */
#ifdef COMMENT
/* All combinations of rwa */
"", "r", "w", "rw", "a", "ra", "wa", "rwa", /* Text mode */
"b", "rb", "wb", "rwb", "ab", "rab", "wab", "rwab" /* Binary mode */
#else
/* Combinations and syntax permitted by C libraries... */
"", "r", "w", "r+", "a", "", "a", "", /* Text mode */
#ifdef OS2
"", "rb", "wb", "r+b", "ab", "", "ab", "" /* Binary modes for K95 */
#else
#ifdef VMS
"", "rb", "wb", "r+b", "ab", "", "ab", "" /* Binary modes for VMS */
#else
"", "r", "w", "r+", "a", "", "a", "" /* Binary modes for UNIX */
#endif /* VMS */
#endif /* OS2 */
#endif /* COMMENT */
};
static int nfopnargs = sizeof(fopnargs) / sizeof(char *);
char * /* Error messages */
ckferror(n) int n; {
switch (n) {
case FX_NER: return("No error");
case FX_SYS: return(ck_errstr());
case FX_EOF: return("End of file");
case FX_NOP: return("File not open");
case FX_CHN: return("Channel out of range");
case FX_RNG: return("Parameter out of range");
case FX_NMF: return("Too many files open");
case FX_FOP: return("Operation conflicts with OPEN mode");
case FX_NYI: return("OPEN mode not supported");
case FX_BOM: return("Illegal combination of OPEN modes");
case FX_ACC: return("Access denied");
case FX_FNF: return("File not found");
case FX_OFL: return("Buffer overflow");
case FX_LNU: return("Current line number unknown");
case FX_UNK: return("Operation fails - reason unknown");
default: return("Error number out of range");
}
}
/*
Z _ O P E N -- Open a file for the requested type of access.
Call with:
name: Name of file to be opened.
flags: Any combination of FM_xxx values except FM_EOF (ckcker.h).
Returns:
>= 0 on success: The assigned channel number
< 0 on failure: A negative FX_xxx error code (ckcker.h).
*/
int
z_open(name, flags) char * name; int flags; {
int i, n;
FILE * t;
char * mode;
debug(F111,"z_open",name,flags);
if (!name) name = ""; /* Check name argument */
if (!name[0])
return(z_error = FX_BFN);
if (flags & FM_CMD) /* Opening pipes not implemented yet */
return(z_error = FX_NYI); /* (and not portable either) */
debug(F101,"z_open nfopnargs","",nfopnargs);
if (flags < 0 || flags >= nfopnargs) /* Range check flags */
return(z_error = FX_RNG);
mode = fopnargs[flags]; /* Get fopen() arg */
debug(F111,"z_open fopen args",mode,flags);
if (!mode[0]) /* Check for illegal combinations */
return(z_error = FX_BOM);
if (!z_inited) { /* If file structs not inited */
debug(F101,"z_open z_maxchan 1","",z_maxchan);
#ifdef UNIX
debug(F101,"z_open ckmaxfiles","",ckmaxfiles);
if (ckmaxfiles > 0) { /* Set in ck?tio.c: sysinit() */
int x;
x = ckmaxfiles - ZNFILS - 5;
if (x > z_maxchan) /* sysconf() value greater than */
z_maxchan = x; /* value from header files. */
debug(F101,"z_open z_maxchan 2","",z_maxchan);
}
#endif /* UNIX */
if (z_maxchan < Z_MINCHAN) /* Allocate at least this many. */
z_maxchan = Z_MINCHAN;
debug(F101,"z_open z_maxchan 3","",z_maxchan);
/* Note: This could be a pretty big chunk of memory */
/* if z_maxchan is a big number. If this becomes a problem */
/* we'll need to malloc and free each element at open/close time */
if (!(z_file = (struct ckz_file *)
malloc(sizeof(struct ckz_file) * (z_maxchan + 1))))
return(z_error = FX_NMF);
for (i = 0; i < z_maxchan; i++) {
z_file[i].z_fp = NULL;
z_file[i].z_flags = 0;
z_file[i].z_nline = 0;
*(z_file[i].z_name) = '';
}
z_inited = 1; /* Remember we did */
}
for (n = -1, i = 0; i < z_maxchan; i++) {
if (!z_file[i].z_fp) {
n = i;
break;
}
}
if (n < 0 || n >= z_maxchan) /* Any free channels? */
return(z_error = FX_NMF); /* No, fail. */
errno = 0;
z_file[n].z_flags = 0; /* In case of failure... */
t = fopen(name, mode); /* Try to open the file. */
if (!t) { /* Failed... */
debug(F111,"z_open error",name,errno);
#ifdef EMFILE
if (errno == EMFILE)
return(z_error = FX_NMF);
#endif /* EMFILE */
return(z_error = (errno ? FX_SYS : FX_UNK)); /* Return error code */
}
#ifdef NT
#ifdef O_SEQUENTIAL
if (t) /* Caching hint for NT */
_setmode(_fileno(t),O_SEQUENTIAL);
#endif /* O_SEQUENTIAL */
#endif /* NT */
z_nopen++; /* Open, count it. */
z_file[n].z_fp = t; /* Stash the file pointer */
z_file[n].z_flags = flags; /* and the flags */
z_error = 0;
zfnqfp(name,CKMAXPATH,z_file[n].z_name); /* and the file's full name */
return(n); /* Return the channel number */
}
int
z_close(channel) int channel; { /* Close file on given channel */
int x;
FILE * t;
if (!z_inited) /* Called before any files are open? */
return(z_error = FX_NOP);
if (channel >= z_maxchan) /* Channel out of range? */
return(z_error = FX_CHN);
if (!(t = z_file[channel].z_fp)) /* Channel wasn't open? */
return(z_error = FX_NOP);
errno = 0; /* Set errno 0 to get a good reading */
x = fclose(t); /* Try to close */
if (x == EOF) /* On failure */
return(z_error = FX_SYS); /* indicate system error. */
z_nopen--; /* Closed OK, decrement open count */
z_file[channel].z_fp = NULL; /* Set file pointer to NULL */
z_file[channel].z_nline = 0; /* Current line number is 0 */
z_file[channel].z_flags = 0; /* Set flags to 0 */
*(z_file[channel].z_name) = ''; /* Clear name */
return(z_error = 0);
}
/*
Z _ O U T -- Output string to channel.
Call with:
channel: Channel number to write to.
s: String to write.
length > -1: How many characters of s to write.
length < 0: Write entire NUL-terminated string.
flags == 0: Supply line termination.
flags > 0: Don't supply line termination.
flags < 0: Write 'length' NUL characters.
Special case:
If flags > -1 and s is empty or NULL and length == 1, write 1 NUL.
Returns:
Number of characters written to channel on success, or
negative FX_xxx error code on failure.
*/
int
z_out(channel,s,length,flags) int channel, flags, length; char * s; {
FILE * t;
int x, n;
char c = '';
if (!s) s = ""; /* Guard against null pointer */
#ifdef DEBUG
if (deblog) {
debug(F111,"z_out",s,channel);
debug(F101,"z_out length","",length);
debug(F101,"z_out flags","",flags);
}
#endif /* DEBUG */
if (!z_inited) /* File i/o inited? */
return(z_error = FX_NOP);
if (channel >= z_maxchan) /* Channel in range? */
return(z_error = FX_CHN);
if (!(t = z_file[channel].z_fp)) /* File open? */
return(z_error = FX_NOP);
if (!((z_file[channel].z_flags) & (FM_WRI|FM_APP))) /* In write mode? */
return(z_error = FX_FOP);
n = length; /* Length of string to write */
if (n < 0) { /* Negative means get it ourselves */
if (flags < 0) /* Except when told to write NULs in */
return(z_error = FX_RNG); /* which case args are inconsistent */
n = strlen(s); /* Get length of string arg */
}
errno = 0; /* Reset errno */
debug(F101,"z_out n","",n);
if (flags < 0) { /* Writing NULs... */
int i;
for (i = 0; i < n; i++) {
x = fwrite(&c,1,1,t);
if (x < 1)
return(z_error = (errno ? FX_SYS : FX_UNK));
}
z_file[channel].z_nline = -1; /* Current line no longer known */
z_error = 0;
return(i);
} else { /* Writing string arg */
if (n == 1 && !s[0]) /* Writing one char but it's NUL */
x = fwrite(&c,1,1,t);
else /* Writing non-NUL char or string */
x = fwrite(s,1,n,t);
debug(F101,"z_out fwrite",ckitoa(x),errno);
if (x < n) /* Failure to write requested amount */
return(z_error = (errno ? FX_SYS : FX_UNK)); /* Return error */
if (flags == 0) { /* If supplying line termination */
if (fwrite("n",1,1,t)) /* do that */
x += z_lt; /* count the terminator */
if (z_file[channel].z_nline > -1) /* count this line */
z_file[channel].z_nline++;
} else {
z_file[channel].z_nline = -1; /* Current line no longer known */
}
}
z_error = 0;
return(x);
}
#define Z_INBUFLEN 64
/*
Z _ I N -- Multichannel i/o file input function.
Call with:
channel number to read from.
s = address of destination buffer.
buflen = destination buffer length.
length = Number of bytes to read, must be < buflen.
flags: 0 = read a line; nonzero = read the given number of bytes.
Returns:
Number of bytes read into buffer or a negative error code.
A terminating NUL is deposited after the last byte that was read.
*/
int
z_in(channel,s,buflen,length,flags)
int channel, buflen, length, flags; char * s;
/* z_in */ {
int i, j, x;
FILE * t;
char * p;
if (!z_inited) /* Check everything... */
return(z_error = FX_NOP);
if (channel >= z_maxchan)
return(z_error = FX_CHN);
if (!(t = z_file[channel].z_fp))
return(z_error = FX_NOP);
if (!((z_file[channel].z_flags) & FM_REA))
return(z_error = FX_FOP);
if (!s) /* Check destination */
return(z_error = FX_RNG);
s[0] = NUL;
if (length == 0) /* Read 0 bytes - easy. */
return(z_error = 0);
debug(F101,"z_in channel","",channel);
debug(F101,"z_in buflen","",buflen);
debug(F101,"z_in length","",length);
debug(F101,"z_in flags","",flags);
if (length < 0 || buflen < 0) /* Check length args */
return(z_error = FX_RNG);
if (buflen <= length)
return(z_error = FX_RNG);
errno = 0; /* Reset errno */
if (flags) { /* Read block or byte */
i = fread(s,1,length,t);
#ifdef DEBUG
if (deblog) {
debug(F111,"z_in block",s,i);
debug(F101,"z_in block errno","",errno);
debug(F101,"z_in block ferror","",ferror(t));
debug(F101,"z_in block feof","",feof(t));
}
#endif /* DEBUG */
z_file[channel].z_nline = -1; /* Current line no longer known */
} else { /* Read line */
#ifndef COMMENT
/* This method is used because it's simpler than the others */
/* and also marginally faster. */
for (i = 0; i < length; i++) {
if ((x = getc(t)) == EOF)
break;
s[i] = x;
if (s[i] == 'n') {
s[i] = '';
break;
}
}
debug(F111,"z_in line byte loop",ckitoa(errno),i);
if (z_file[channel].z_nline > -1)
z_file[channel].z_nline++;
#else
#ifdef COMMENT2
/* Straightforward but strlen() slows it down. */
s[0] = '';
i = 0;
if (fgets(s,length,t)) {
i = strlen(s);
if (i > 0 && s[i-1] == 'n') i--;
}
debug(F111,"z_in line fgets",ckitoa(errno),i);
if (z_file[channel].z_nline > -1)
z_file[channel].z_nline++;
#else
/* This is a do-it-yourself fgets() with its own readahead and */
/* putback. It's a bit faster than real fgets() but not enough */
/* to justify the added complexity or the risk of the ftell() and */
/* fseek() calls failing. */
int k, flag = 0;
long pos;
for (i = 0; !flag && i <= (length - Z_INBUFLEN); i += Z_INBUFLEN) {
k = ((length - i) < Z_INBUFLEN) ? length - i : Z_INBUFLEN;
if ((x = fread(s+i,1,k,t)) < 1)
break;
s[i+x] = '';
for (j = 0; j < x; j++) {
if (s[i+j] == 'n') {
s[i+j] = '';
flag ++;
pos = ftell(t);
if (pos > -1) {
pos -= (x - j - 1);
x = fseek(t, pos, 0);
i += j;
break;
} else
return(z_error = FX_SYS);
}
}
}
if (z_file[channel].z_nline > -1)
z_file[channel].z_nline++;
debug(F111,"z_in line chunk loop",ckitoa(errno),i);
#endif /* COMMENT2 */
#endif /* COMMENT */
}
debug(F111,"z_in i",ckitoa(errno),i);
if (i < 0) i = 0; /* NUL-terminate result */
s[i] = '';
if (i > 0) {
z_error = 0;
return(i);
}
if (i == 0 && feof(t)) /* EOF on reading? */
return(z_error = FX_EOF); /* Return EOF code */
return(errno ? (z_error = -1) : i); /* Return length or system error */
}
int
z_flush(channel) int channel; { /* Flush output channel */
FILE * t;
int x;
if (!z_inited) /* Regular checks */
return(z_error = FX_NOP);
if (channel >= z_maxchan)
return(z_error = FX_CHN);
if (!(t = z_file[channel].z_fp))
return(z_error = FX_NOP);
if (!((z_file[channel].z_flags) & (FM_WRI|FM_APP))) /* Write access? */
return(z_error = FX_FOP);
errno = 0; /* Reset errno */
x = fflush(t); /* Try to flush */
return(x ? (z_error = FX_SYS) : 0); /* Return system error or 0 if OK */
}
int
#ifdef CK_ANSIC
z_seek(int channel, long pos) /* Move file pointer to byte */
#else
z_seek(channel,pos) int channel; long pos; /* (seek to given position) */
#endif /* CK_ANSIC */
{
int i, x = 0, rc;
FILE * t;
if (!z_inited) /* Check... */
return(z_error = FX_NOP);
if (channel >= z_maxchan)
return(z_error = FX_CHN);
if (!(t = z_file[channel].z_fp))
return(z_error = FX_NOP);
if (pos < 0L) {
x = 2;
pos = (pos == -2) ? -1L : 0L;
}
errno = 0;
rc = fseek(t,pos,x); /* Try to seek */
debug(F111,"z_seek",ckitoa(errno),rc);
if (rc < 0) /* OK? */
return(z_error = FX_SYS); /* No. */
z_file[channel].z_nline = ((pos || x) ? -1 : 0);
return(z_error = 0);
}
int
#ifdef CK_ANSIC
z_line(int channel, long pos) /* Move file pointer to line */
#else
z_line(channel,pos) int channel; long pos; /* (seek to given position) */
#endif /* CK_ANSIC */
{
int i, len, x = 0;
long current = 0L, prev = -1L, old = -1L;
FILE * t;
char tmpbuf[256];
if (!z_inited) /* Check... */
return(z_error = FX_NOP);
if (channel >= z_maxchan)
return(z_error = FX_CHN);
if (!(t = z_file[channel].z_fp))
return(z_error = FX_NOP);
debug(F101,"z_line pos","",pos);
if (pos < 0L) { /* EOF wanted */
long n;
n = z_file[channel].z_nline;
if (n < 0) {
rewind(t);
n = 0;
}
while (1) { /* This could take a while... */
if ((x = getc(t)) == EOF)
break;
if (x == 'n') {
n++;
if (pos == -2) {
old = prev;
prev = ftell(t);
}
}
}
if (pos == -2) {
if ((x = z_seek(channel,old)) < 0)
return(z_error = x);
else
n--;
}
z_file[channel].z_nline = n;
return(z_error = 0);
}
if (pos == 0L) { /* Rewind wanted */
z_file[channel].z_nline = 0L;
rewind(t);
debug(F100,"z_line rewind","",0);
return(0L);
}
tmpbuf[255] = NUL; /* Make sure buf is NUL terminated */
current = z_file[channel].z_nline; /* Current line */
/*
If necessary the following could be optimized, e.g. for positioning
to a previous line in a large file without starting over.
*/
if (current < 0 || pos < current) { /* Not known or behind us... */
debug(F101,"z_line rewinding","",pos);
if ((x = z_seek(channel, 0L)) < 0) /* Rewind */
return(z_error = x);
if (pos == 0) /* If 0th line wanted we're done */
return(z_error = 0);
current = 0;
}
while (current < pos) { /* Search for specified line */
if (fgets(tmpbuf,255,t)) {
len = strlen(tmpbuf);
if (len > 0 && tmpbuf[len-1] == 'n') {
current++;
debug(F111,"z_line read",ckitoa(len),current);
} else if (len == 0) {
return(z_error = FX_UNK);
}
} else {
z_file[channel].z_nline = -1L;
debug(F101,"z_line premature EOF","",current);
return(z_error = FX_EOF);
}
}
z_file[channel].z_nline = current;
debug(F101,"z_line result","",current);
z_error = 0;
return(current);
}
char *
z_getname(channel) int channel; { /* Return name of file on channel */
FILE * t;
if (!z_inited) {
z_error = FX_NOP;
return(NULL);
}
if (channel >= z_maxchan) {
z_error = FX_CHN;
return(NULL);
}
if (!(t = z_file[channel].z_fp)) {
z_error = FX_NOP;
return(NULL);
}
return((char *)(z_file[channel].z_name));
}
int
z_getmode(channel) int channel; { /* Return OPEN modes of channel */
FILE * t; /* 0 if file not open */
#ifndef NOSTAT
struct stat statbuf;
#endif /* NOSTAT */
int x;
if (!z_inited)
return(0);
if (channel >= z_maxchan)
return(z_error = FX_CHN);
if (!(t = z_file[channel].z_fp))
return(0);
x = z_file[channel].z_flags;
if (feof(t)) { /* This might not work for */
x |= FM_EOF; /* output files */
#ifndef NOSTAT
/* But this does if we can use it. */
} else if (stat(z_file[channel].z_name,&statbuf) > -1) {
if (ftell(t) == statbuf.st_size)
x |= FM_EOF;
#endif /* NOSTAT */
}
return(x);
}
long
z_getpos(channel) int channel; { /* Get file pointer position */
FILE * t; /* on this channel */
long x;
if (!z_inited)
return(z_error = FX_NOP);
if (channel >= z_maxchan)
return(z_error = FX_CHN);
if (!(t = z_file[channel].z_fp))
return(z_error = FX_NOP);
x = ftell(t);
return((x < 0L) ? (z_error = FX_SYS) : x);
}
long
z_getline(channel) int channel; { /* Get current line number */
FILE * t; /* in file on this channel */
long rc;
if (!z_inited)
return(z_error = FX_NOP);
if (channel >= z_maxchan)
return(z_error = FX_CHN);
if (!(t = z_file[channel].z_fp))
return(z_error = FX_NOP);
debug(F101,"z_getline","",z_file[channel].z_nline);
rc = z_file[channel].z_nline;
return((rc < 0) ? (z_error = FX_LNU) : rc);
}
int
z_getfnum(channel) int channel; { /* Get file number / handle */
FILE * t; /* for file on this channel */
if (!z_inited)
return(z_error = FX_NOP);
if (channel >= z_maxchan)
return(z_error = FX_CHN);
if (!(t = z_file[channel].z_fp))
return(z_error = FX_NOP);
z_error = 0;
return(fileno(t));
}
/*
Line-oriented counts and seeks are as dumb as they can be at the moment.
Later we can speed them up by building little indexes.
*/
long
z_count(channel, what) int channel, what; { /* Count bytes or lines in file */
FILE * t;
int i, x;
long pos, count = 0L;
if (!z_inited) /* Check stuff... */
return(z_error = FX_NOP);
if (channel >= z_maxchan)
return(z_error = FX_CHN);
if (!(t = z_file[channel].z_fp))
return(z_error = FX_NOP);
pos = ftell(t); /* Save current file pointer */
errno = 0;
z_error = 0;
if (what == RD_CHAR) { /* Size in bytes requested */
if (!fseek(t,0L,2)) { /* Seek to end */
count = ftell(t); /* Get file pointer */
fseek(t,pos,0); /* Restore file file pointer */
return(count);
} else /* Fallback in case seek fails */
return(zgetfs(z_file[channel].z_name));
}
rewind(t); /* Line count requested - rewind. */
while (1) { /* Count lines. */
if ((x = getc(t)) == EOF) /* Stupid byte loop */
break; /* but it works as well as anything */
if (x == 'n') /* else... */
count++;
}
x = fseek(t,pos,0); /* Restore file pointer */
return(count);
}
/* User interface for generalized channel-oriented file i/o */
struct keytab fctab[] = { /* FILE subcommands */
"close", FIL_CLS, 0,
"count", FIL_COU, 0,
"flush", FIL_FLU, 0,
"list", FIL_LIS, 0,
"open", FIL_OPN, 0,
"read", FIL_REA, 0,
"rewind", FIL_REW, 0,
"seek", FIL_SEE, 0,
"status", FIL_STA, 0,
"write", FIL_WRI, 0
};
int nfctab = (sizeof (fctab) / sizeof (struct keytab));
static struct keytab fcswtab[] = { /* OPEN modes */
"/append", FM_APP, 0,
"/binary", FM_BIN, 0,
#ifdef COMMENT
"/command", FM_CMD, 0, /* Not implemented */
#endif /* COMMENT */
"/read", FM_REA, 0,
"/write", FM_WRI, 0
};
static int nfcswtab = (sizeof (fcswtab) / sizeof (struct keytab));
static struct keytab fclkwtab[] = { /* CLOSE options */
"all", 1, 0
};
static struct keytab fsekwtab[] = { /* SEEK symbols */
"eof", 1, 0,
"last", 2, 0
};
static int nfsekwtab = (sizeof (fsekwtab) / sizeof (struct keytab));
#define SEE_LINE RD_LINE /* SEEK options */
#define SEE_CHAR RD_CHAR
#define SEE_REL 3
#define SEE_ABS 4
static struct keytab fskswtab[] = {
"/absolute", SEE_ABS, 0,
"/byte", SEE_CHAR, 0,
"/character", SEE_CHAR, CM_INV,
"/line", SEE_LINE, 0,
"/relative", SEE_REL, 0
};
static int nfskswtab = (sizeof (fskswtab) / sizeof (struct keytab));
#define COU_LINE RD_LINE /* COUNT options */
#define COU_CHAR RD_CHAR
#define COU_LIS 3
#define COU_NOL 4
static struct keytab fcoswtab[] = {
"/bytes", COU_CHAR, 0,
"/characters",COU_CHAR, CM_INV,
"/lines", COU_LINE, 0,
"/list", COU_LIS, 0,
"/nolist", COU_NOL, 0,
"/quiet", COU_NOL, CM_INV
};
static int nfcoswtab = (sizeof (fcoswtab) / sizeof (struct keytab));
static struct keytab frdtab[] = { /* READ types */
"/block", RD_SIZE, CM_INV|CM_ARG,
"/byte", RD_CHAR, CM_INV,
"/character", RD_CHAR, 0,
"/line", RD_LINE, 0,
"/size", RD_SIZE, CM_ARG
};
static int nfrdtab = (sizeof (frdtab) / sizeof (struct keytab));
static struct keytab fwrtab[] = { /* WRITE types */
"/block", WR_SIZE, CM_INV|CM_ARG,
"/byte", WR_CHAR, CM_INV,
"/character", WR_CHAR, 0,
"/line", WR_LINE, 0,
"/lpad", WR_LPAD, CM_ARG,
"/rpad", WR_RPAD, CM_ARG,
"/size", WR_SIZE, CM_ARG,
"/string", WR_STRI, 0
};
static int nfwrtab = (sizeof (fwrtab) / sizeof (struct keytab));
static char blanks[] = "40404040"; /* Some blanks for formatting */
int
dofile(op) int op; { /* Do the FILE command */
char vnambuf[VNAML]; /* Buffer for variable names */
char *vnp = NULL; /* Pointer to same */
char zfilnam[CKMAXPATH+2];
char * p;
struct FDB fl, sw, nu;
long z;
int rsize, filmode = 0, relative = -1, eofflg = 0;
int rc, x, y, cx, n, getval, dummy, confirmed, listing = -1;
int charflag = 0, sizeflag = 0;
int pad = 32, wr_lpad = 0, wr_rpad = 0;
if (op == XXFILE) { /* FILE command was given */
/* Get subcommand */
if ((cx = cmkey(fctab,nfctab,"Operation","",xxstring)) < 0) {
if (cx == -3) {
printf("?File operation requiredn");
x = -9;
}
return(cx);
}
} else { /* Shorthand command was given */
switch (op) {
case XXF_CL: cx = FIL_CLS; break; /* FCLOSE */
case XXF_FL: cx = FIL_FLU; break; /* FFLUSH */
case XXF_LI: cx = FIL_LIS; break; /* FLIST */
case XXF_OP: cx = FIL_OPN; break; /* etc... */
case XXF_RE: cx = FIL_REA; break;
case XXF_RW: cx = FIL_REW; break;
case XXF_SE: cx = FIL_SEE; break;
case XXF_ST: cx = FIL_STA; break;
case XXF_WR: cx = FIL_WRI; break;
case XXF_CO: cx = FIL_COU; break;
default: return(-2);
}
}
switch (cx) { /* Do requested subcommand */
case FIL_OPN: /* OPEN */
cmfdbi(&sw, /* Switches */
_CMKEY, /* fcode */
"Variable or switch", /* hlpmsg */
"", /* default */
"", /* addtl string data */
nfcswtab, /* addtl numeric data 1: tbl size */
4, /* addtl numeric data 2: 4 = cmswi */
xxstring, /* Processing function */
fcswtab, /* Keyword table */
&fl /* Pointer to next FDB */
);
cmfdbi(&fl, /* Anything that doesn't match */
_CMFLD, /* fcode */
"Variable", /* hlpmsg */
"",
"",
0,
0,
NULL,
NULL,
NULL
);
while (1) {
x = cmfdb(&sw); /* Parse something */
if (x < 0) {
if (x == -3) {
printf("?Variable name and file name requiredn");
x = -9;
}
return(x);
}
if (cmresult.fcode == _CMFLD)
break;
else if (cmresult.fcode == _CMKEY) {
char c;
c = cmgbrk();
if ((getval =
(c == ':' || c == '=')) && !(cmgkwflgs() & CM_ARG)) {
printf("?This switch does not take an argumentn");
return(-9);
}
#ifdef COMMENT
/* Uncomment if we add any switches ere that take args */
if (!getval && (cmgkwflgs() & CM_ARG)) {
printf("?This switch requires an argumentn");
return(-9); /* (none do...) */
}
#endif /* COMMENT */
filmode |= cmresult.nresult; /* OR in the file mode */
} else
return(-2);
}
strcpy(vnambuf,cmresult.sresult); /* Not a switch - get the string */
if (!vnambuf[0] || chknum(vnambuf)) { /* (if there is one...) */
printf("?Variable name requiredn");
return(-9);
}
vnp = vnambuf; /* Check variable-name syntax */
if (vnambuf[0] == CMDQ &&
(vnambuf[1] == '%' || vnambuf[1] == '&'))
vnp++;
y = 0;
if (*vnp == '%' || *vnp == '&') {
if ((y = parsevar(vnp,&x,&dummy)) < 0) {
printf("?Syntax error in variable namen");
return(-9);
}
}
if (!(filmode & FM_RWA)) /* If no access mode specified */
filmode |= FM_REA; /* default to /READ. */
y = 0; /* Now parse the filename */
if ((filmode & FM_RWA) == FM_WRI)
x = cmofi("Name of new file","",&s,xxstring);
else if ((filmode & FM_RWA) == FM_REA)
x = cmifi("Name of existing file","",&s,&y,xxstring);
else {
x = cmiofi("Filename","",&s,&y,xxstring);
debug(F101,"fopen /append x","",x);
}
if (x == -9) {
if (zchko(s) < 0) {
printf("Can't create "%s"n",s);
return(x);
}
} else if (x < 0) {
if (x == -3) {
printf("?Filename requiredn");
x = -9;
}
return(x);
}
if (y) { /* No wildcards */
printf("?Wildcards not allowed heren");
return(-9);
}
if (filmode & (FM_APP|FM_WRI)) { /* Check output access */
if (zchko(s) < 0) { /* and set error code if denied */
z_error = FX_ACC;
printf("?Write access denied - "%s"n",s);
return(-9);
}
}
ckstrncpy(zfilnam,s,CKMAXPATH); /* Is OK - make safe copy */
if ((x = cmcfm()) < 0) /* Get confirmation of command */
return(x);
if ((n = z_open(zfilnam,filmode)) < 0) {
printf("?OPEN failed - %s: %sn",zfilnam,ckferror(n));
return(-9);
}
addmac(vnambuf,ckitoa(n)); /* Assign channel number to variable */
return(success = 1);
case FIL_REW: /* REWIND */
if ((x = cmnum("Channel number","",10,&n, xxstring)) < 0) {
if (x == -3) {
printf("?Channel number requiredn");
x = -9;
}
return(x);
}
if ((x = cmcfm()) < 0)
return(x);
if ((rc = z_seek(n,0L)) < 0) {
printf("?REWIND failed - Channel %d: %sn",n,ckferror(rc));
return(-9);
}
return(success = 1);
case FIL_CLS: /* CLOSE */
cmfdbi(&sw, /* Second FDB - switches */
_CMKEY, /* fcode */
"Channel number; or keyword",
"",
"", /* addtl string data */
1, /* addtl numeric data 1: tbl size */
0, /* addtl numeric data 2: 4 = cmswi */
xxstring, /* Processing function */
fclkwtab, /* Keyword table */
&nu /* Pointer to next FDB */
);
cmfdbi(&nu, /* First FDB - command switches */
_CMNUM, /* fcode */
"",
"", /* default */
"", /* addtl string data */
10, /* addtl numeric data 1: radix */
0, /* addtl numeric data 2: 0 */
xxstring, /* Processing function */
NULL, /* Keyword table */
NULL /* Pointer to next FDB */
); /* */
x = cmfdb(&sw); /* Parse something */
if (x < 0) {
if (x == -3) {
printf("?Channel number or ALL requiredn");
x = -9;
}
return(x);
}
if (cmresult.fcode == _CMNUM)
n = cmresult.nresult;
else if (cmresult.fcode == _CMKEY)
n = -1;
if ((x = cmcfm()) < 0)
return(x);
rc = 1;
if (n < 0) {
int count = 0;
int i;
for (i = 0; i < z_maxchan; i++) {
x = z_close(i);
if (x == FX_SYS) {
printf("?CLOSE failed - Channel %d: %sn",n,ckferror(x));
rc = 0;
} else if (x > -1)
count++;
}
debug(F101,"FILE CLOSE ALL","",count);
} else if ((x = z_close(n)) < 0) {
printf("?CLOSE failed - Channel %d: %sn",n,ckferror(x));
return(-9);
}
return(success = rc);
case FIL_REA: /* READ */
case FIL_WRI: /* WRITE */
rsize = 0;
cmfdbi(&sw, /* Switches */
_CMKEY, /* fcode */
"Channel or switch", /* hlpmsg */
"", /* default */
"", /* addtl string data */
(cx == FIL_REA) ? nfrdtab : nfwrtab,
4, /* addtl numeric data 2: 4 = cmswi */
xxstring, /* Processing function */
(cx == FIL_REA) ? frdtab : fwrtab, /* Keyword table */
&nu /* Pointer to next FDB */
);
cmfdbi(&nu, /* Channel number */
_CMNUM, /* fcode */
"Channel",
"", /* default */
"", /* addtl string data */
10, /* addtl numeric data 1: radix */
0, /* addtl numeric data 2: 0 */
xxstring, /* Processing function */
NULL, /* Keyword table */
NULL /* Pointer to next FDB */
);
do {
x = cmfdb(&sw); /* Parse something */
if (x < 0) {
if (x == -3) {
printf("?Channel number requiredn");
x = -9;
}
return(x);
}
if (cmresult.fcode == _CMNUM) /* Channel number */
break;
else if (cmresult.fcode == _CMKEY) { /* Switch */
char c;
c = cmgbrk();
if ((getval =
(c == ':' || c == '=')) && !(cmgkwflgs() & CM_ARG)) {
printf("?This switch does not take an argumentn");
return(-9);
}
if (!getval && (cmgkwflgs() & CM_ARG)) {
printf("?This switch requires an argumentn");
return(-9);
}
switch (cmresult.nresult) {
case WR_LINE:
charflag = 0;
sizeflag = 0;
rsize = 0;
break;
case WR_CHAR:
rsize = 1;
charflag = 1;
sizeflag = 1;
break;
case WR_SIZE:
if ((x = cmnum("Bytes","",10,&rsize, xxstring)) < 0) {
if (x == -3) {
printf("?Number requiredn");
x = -9;
}
return(x);
}
charflag = 0;
sizeflag = 1;
break;
case WR_STRI:
rsize = 1;
charflag = 0;
sizeflag = 0;
break;
case WR_LPAD:
case WR_RPAD:
if ((x = cmnum("Numeric ASCII character value",
"32",10,&pad, xxstring)) < 0)
return(x);
if (cmresult.nresult == WR_LPAD)
wr_lpad = 1;
else
wr_rpad = 1;
break;
}
debug(F101,"FILE READ rsize 2","",rsize);
} else
return(-2);
} while
(cmresult.fcode == _CMKEY);
n = cmresult.nresult; /* Channel */
debug(F101,"FILE READ/WRITE channel","",n);
if (cx == FIL_WRI) { /* WRITE */
int len = 0;
if ((x = cmtxt("Text","",&s,xxstring)) < 0)
return(x);
strcpy(line,s); /* Make a safe copy */
s = line;
s = brstrip(s); /* Strip braces */
if (charflag) { /* Write one char */
len = 1; /* So length = 1 */
rsize = 1; /* Don't supply terminator */
} else if (!sizeflag) { /* Write a string */
len = -1; /* So length is unspecified */
} else { /* Write a block of given size */
int i, k, xx;
if (rsize > TMPBUFSIZ) {
z_error = FX_OFL;
printf("?Buffer overflown");
return(-9);
}
len = rsize; /* rsize is really length */
rsize = 1; /* Don't supply a terminator */
xx = strlen(s); /* Size of given string */
if (xx >= len) { /* Bigger or equal */
s[len] = NUL;
} else if (wr_lpad) { /* Smaller, left-padding requested */
for (i = 0; i < len - xx; i++) /* Must make a copy */
tmpbuf[i] = pad;
strcpy(tmpbuf+i,s);
tmpbuf[len] = NUL;
s = tmpbuf; /* Redirect write source */
} else { /* Smaller with right-padding */
for (i = xx; i < len; i++)
s[i] = pad;
s[len] = NUL;
}
}
if ((rc = z_out(n,s,len,rsize)) < 0) { /* Try to write */
printf("?Channel %d WRITE error: %sn",n,ckferror(rc));
return(-9);
}
} else { /* FIL_REA READ */
confirmed = 0;
vnambuf[0] = NUL;
x = cmfld("Variable name","",&s,NULL);
debug(F111,"FILE READ cmfld",s,x);
if (x < 0) {
if (x == -3 || !*s) {
if ((x = cmcfm()) < 0)
return(x);
else
confirmed++;
} else
return(x);
}
strcpy(vnambuf,s);
debug(F111,"FILE READ vnambuf",vnambuf,confirmed);
if (vnambuf[0]) { /* Variable name given, check it */
if (!confirmed) {
x = cmcfm();
if (x < 0)
return(x);
else
confirmed++;
}
vnp = vnambuf;
if (vnambuf[0] == CMDQ &&
(vnambuf[1] == '%' || vnambuf[1] == '&'))
vnp++;
y = 0;
if (*vnp == '%' || *vnp == '&') {
if ((y = parsevar(vnp,&x,&dummy)) < 0) {
printf("?Syntax error in variable namen");
return(-9);
}
}
}
debug(F111,"FILE READ variable",vnambuf,confirmed);
if (!confirmed)
if ((x = cmcfm()) < 0)
return(x);
line[0] = NUL; /* Clear destination buffer */
if (rsize >= LINBUFSIZ) /* Don't overrun it */
rsize = LINBUFSIZ - 1;
if (rsize == 0) /* Read a line */
rc = z_in(n,line,LINBUFSIZ,LINBUFSIZ-1,0);
else
rc = z_in(n,line,LINBUFSIZ,rsize,1); /* Read a block */
if (rc < 0) { /* Error... */
debug(F101,"FILE READ error","",rc);
debug(F101,"FILE READ errno","",errno);
if (rc == FX_EOF) { /* EOF - fail but no error message */
return(success = 0);
} else { /* Other error - fail and print msg */
printf("?READ error: %sn",ckferror(rc));
return(-9);
}
}
debug(F110,"FILE READ data",line,0);
if (vnambuf[0]) /* Read OK - If variable name given */
addmac(vnambuf,line); /* Assign result to variable */
else /* otherwise */
printf("%sn",line); /* just print it */
}
return(success = 1);
case FIL_SEE: /* SEEK */
case FIL_COU: /* COUNT */
rsize = RD_CHAR; /* Defaults to /BYTE */
cmfdbi(&sw, /* Switches */
_CMKEY, /* fcode */
"Channel or switch", /* hlpmsg */
"", /* default */
"", /* addtl string data */
((cx == FIL_SEE) ? nfskswtab : nfcoswtab),
4, /* addtl numeric data 2: 4 = cmswi */
xxstring, /* Processing function */
((cx == FIL_SEE) ? fskswtab : fcoswtab),
&nu /* Pointer to next FDB */
);
cmfdbi(&nu, /* Channel number */
_CMNUM, /* fcode */
"Channel",
"", /* default */
"", /* addtl string data */
10, /* addtl numeric data 1: radix */
0, /* addtl numeric data 2: 0 */
xxstring, /* Processing function */
NULL, /* Keyword table */
NULL /* Pointer to next FDB */
);
do {
x = cmfdb(&sw); /* Parse something */
if (x < 0) {
if (x == -3) {
printf("?Channel number requiredn");
x = -9;
}
return(x);
}
if (cmresult.fcode == _CMNUM) /* Channel number */
break;
else if (cmresult.fcode == _CMKEY) { /* Switch */
char c;
c = cmgbrk();
if ((getval =
(c == ':' || c == '=')) && !(cmgkwflgs() & CM_ARG)) {
printf("?This switch does not take an argumentn");
return(-9);
}
if (cx == FIL_SEE) {
switch (cmresult.nresult) {
case SEE_REL: relative = 1; break;
case SEE_ABS: relative = 0; break;
default: rsize = cmresult.nresult;
}
} else if (cx == FIL_COU) {
switch (cmresult.nresult) {
case COU_LIS: listing = 1; break;
case COU_NOL: listing = 0; break;
default: rsize = cmresult.nresult;
}
}
}
} while
(cmresult.fcode == _CMKEY);
n = cmresult.nresult; /* Channel */
debug(F101,"FILE SEEK/COUNT channel","",n);
if (cx == FIL_COU) {
if ((x = cmcfm()) < 0)
return(x);
z_filcount = z_count(n,rsize);
if (z_filcount < 0) {
rc = z_filcount;
printf("?COUNT error: %sn",ckferror(rc));
return(-9);
}
if (listing < 0)
listing = !cmdsrc();
if (listing)
printf(" %ld %s%sn",
z_filcount,
((rsize == RD_CHAR) ? "byte" : "line"),
((z_filcount == 1L) ? "" : "s")
);
return(success = (z_filcount > -1) ? 1 : 0);
}
cmfdbi(&sw, /* SEEK symbolic targets (EOF) */
_CMKEY, /* fcode */
"Channel number;n or keyword",
"",
"", /* addtl string data */
nfsekwtab, /* addtl numeric data 1: table size */
0, /* addtl numeric data 2: 4 = cmswi */
xxstring, /* Processing function */
fsekwtab, /* Keyword table */
&nu /* Pointer to next FDB */
);
cmfdbi(&nu, /* Channel number */
_CMNUM, /* fcode */
"",
"", /* default */
"", /* addtl string data */
10, /* addtl numeric data 1: radix */
0, /* addtl numeric data 2: 0 */
xxstring, /* Processing function */
NULL, /* Keyword table */
NULL /* Pointer to next FDB */
);
x = cmfdb(&sw); /* Parse something */
if (x < 0) {
if (x == -3) {
printf("?Channel number or EOF requiredn");
x = -9;
}
return(x);
}
if (cmresult.fcode == _CMNUM) {
y = cmresult.nresult;
debug(F110,"FILE SEEK atmbuf",atmbuf,0);
if (relative < 0) {
if (cx == FIL_SEE && (atmbuf[0] == '+' || atmbuf[0] == '-'))
relative = 1;
else
relative = 0;
}
} else if (cmresult.fcode == _CMKEY) {
eofflg = cmresult.nresult;
relative = 0;
y = 0 - eofflg;
}
if ((x = cmcfm()) < 0)
return(x);
z = y; /* Convert to long */
y = 1; /* Recycle this */
z_flush(n);
debug(F101,"FILE SEEK relative","",relative);
debug(F101,"FILE SEEK rsize","",rsize);
if (rsize == RD_CHAR) { /* Seek to byte position */
if (relative) {
long pos;
pos = z_getpos(n);
if (pos < 0L) {
rc = pos;
printf("?Relative SEEK failed: %sn",ckferror(rc));
return(-9);
}
z += pos;
} else {
if (z < 0 && !eofflg) { /* Negative arg but not relative */
y = 0; /* Remember this was bad */
z = 0; /* but substitute 0 */
}
}
debug(F101,"FILE SEEK /CHAR z","",z);
if (z < 0 && !eofflg) {
z_error = FX_RNG;
return(success = 0);
}
if ((rc = z_seek(n,z)) < 0) {
if (rc == FX_EOF) return(success = 0);
printf("?SEEK /BYTE failed - Channel %d: %sn",n,ckferror(rc));
return(-9);
}
} else { /* Seek to line */
if (relative) {
long pos;
pos = z_getline(n);
debug(F101,"FILE SEEK /LINE pos","",pos);
if (pos < 0L) {
rc = pos;
printf("?Relative SEEK failed: %sn",ckferror(rc));
return(-9);
}
z += pos;
}
debug(F101,"FILE SEEK /LINE z","",z);
if (z < 0 && !eofflg) {
z_error = FX_RNG;
return(success = 0);
}
if ((rc = z_line(n,z)) < 0) {
if (rc == FX_EOF) return(success = 0);
printf("?SEEK /LINE failed - Channel %d: %sn",n,ckferror(rc));
return(-9);
}
}
return(success = y);
case FIL_LIS: { /* LIST open files */
#ifdef CK_TTGWSIZ
extern int cmd_rows, cmd_cols;
#endif /* CK_TTGWSIZ */
extern int xaskmore;
int i, x, n = 0, paging = 0;
char * s;
if ((x = cmcfm()) < 0)
return(x);
#ifdef CK_TTGWSIZ
if (cmd_rows > 0 && cmd_cols > 0)
#endif /* CK_TTGWSIZ */
paging = xaskmore;
printf("System open file limit: %4dn", z_openmax);
printf("Maximum for FILE OPEN: %4dn", z_maxchan);
printf("Files currently open: %4dnn", z_nopen);
n = 4;
for (i = 0; i < z_maxchan; i++) {
s = z_getname(i); /* Got one? */
if (s) { /* Yes */
char m[8];
m[0] = NUL;
printf("%2d. %s",i,s); /* Print name */
n++; /* Count it */
x = z_getmode(i); /* Get modes & print them */
if (x > -1) {
if (x & FM_REA) strcat(m,"R");
if (x & FM_WRI) strcat(m,"W");
if (x & FM_APP) strcat(m,"A");
if (x & FM_BIN) strcat(m,"B");
if (m[0])
printf(" (%s)",m);
if (x & FM_EOF)
printf(" [EOF]");
else
printf(" %ld",z_getpos(i)); /* And file position too */
}
printf("n");
#ifdef CK_TTGWSIZ
if (paging > 0) { /* Pause at end of screen */
if (n > cmd_rows - 3) {
if (!askmore())
break;
else
n = 0;
}
}
#endif /* CK_TTGWSIZ */
}
}
return(success = 1);
}
case FIL_FLU: /* FLUSH */
if ((x = cmnum("Channel number","",10,&n, xxstring)) < 0) {
if (x == -3) {
printf("?Channel number requiredn");
x = -9;
}
return(x);
}
if ((x = cmcfm()) < 0)
return(x);
if ((rc = z_flush(n)) < 0) {
printf("?FLUSH failed - Channel %d: %sn",n,ckferror(rc));
return(-9);
}
return(success = 1);
case FIL_STA: /* STATUS */
if ((x = cmnum("Channel number","",10,&n, xxstring)) < 0) {
if (x == -3) {
printf("?Channel number requiredn");
x = -9;
}
return(x);
}
if ((x = cmcfm()) < 0)
return(x);
p = blanks + 3; /* Tricky formatting... */
if (n < 1000) p--;
if (n < 100) p--;
if (n < 10) p--;
if ((rc = z_getmode(n)) < 0) {
printf("Channel %d:%s%sn",n,p,ckferror(rc));
return(success = 0);
} else if (!rc) {
printf("Channel %d:%sNot openn",n,p);
return(success = 0);
} else {
long xx;
s = z_getname(n);
if (!s) s = "(name unknown)";
printf("Channel %d:%sOpenn",n,p);
printf(" File: %sn Modes: ",s);
if (rc & FM_REA) printf(" /READ");
if (rc & FM_WRI) printf(" /WRITE");
if (rc & FM_APP) printf(" /APPEND");
if (rc & FM_BIN) printf(" /BINARY");
if (rc & FM_CMD) printf(" /COMMAND");
if (rc & FM_EOF) printf(" [EOF]");
printf("n Size: %ldn",z_count(n,RD_CHAR));
printf(" At byte: %ldn",z_getpos(n));
xx = z_getline(n);
if (xx > -1)
printf(" At line: %ldn",xx);
return(success = 1);
}
default:
return(-2);
}
}
#endif /* CKCHANNELIO */
#ifndef NOSETKEY
/* Save Key maps and in OS/2 Mouse maps */
int
savkeys(name,disp) char * name; int disp; {
char *tp;
static struct filinfo xx;
int savfil, i, j, k;
char buf[1024];
zclose(ZMFILE);
if (disp) {
xx.bs = 0; xx.cs = 0; xx.rl = 0; xx.org = 0; xx.cc = 0;
xx.typ = 0; xx.dsp = XYFZ_A; xx.os_specific = '';
xx.lblopts = 0;
savfil = zopeno(ZMFILE,name,NULL,&xx);
} else savfil = zopeno(ZMFILE,name,NULL,NULL);
if (savfil) {
#ifdef OS2
ztime(&tp);
zsout(ZMFILE, "; Kermit 95 SAVE KEYMAP file: ");
zsoutl(ZMFILE,tp);
if (mskkeys) {
zsoutl(ZMFILE,
"if eq "\v(program)" "C-Kermit" set mskermit keycodes on");
} else {
zsoutl(ZMFILE,
"if NOT eq "\v(program)" "C-Kermit" stop 1 C-Kermit required.");
zsoutl(ZMFILE,"set mskermit keycodes off");
}
zsoutl(ZMFILE,"");
#else /* OS2 */
ztime(&tp);
zsout(ZMFILE, "; C-Kermit SAVE KEYMAP file: ");
zsoutl(ZMFILE,tp);
#endif /* OS2 */
zsoutl(ZMFILE,"; Clear previous keyboard mappings ");
zsoutl(ZMFILE,"set key clear");
#ifdef OS2
for (k = 0; k < nttkey; k++) {
if (!ttkeytab[k].flgs) {
sprintf(buf, "set terminal key %s clear", ttkeytab[k].kwd);
zsoutl(ZMFILE,buf);
}
}
#endif /* OS2 */
zsoutl(ZMFILE,"");
for (i = 0; i < KMSIZE; i++) {
if (macrotab[i]) {
int len = strlen((char *)macrotab[i]);
#ifdef OS2
sprintf(buf,"set key \%d ",mskkeys ? cktomsk(i) : i);
#else /* OS2 */
sprintf(buf,"set key \%d ",i);
#endif /* OS2 */
zsout(ZMFILE,buf);
for (j = 0; j < len; j++) {
char ch = macrotab[i][j];
if (ch <= SP || ch >= DEL ||
ch == '-' || ch == ',' ||
ch == '{' || ch == '}' ||
ch == ';' || ch == '?' ||
ch == '.' || ch == ''' ||
ch == '\' || ch == '/' ||
ch == '#') {
sprintf(buf, "\{%d}", ch);
zsout(ZMFILE,buf);
} else {
sprintf(buf, "%c", ch);
zsout(ZMFILE,buf);
}
}
#ifdef OS2
sprintf(buf, "t; %s", keyname(i));
zsoutl(ZMFILE,buf);
#else
zsoutl(ZMFILE,"");
#endif /* OS2 */
} else if ( keymap[i] != i ) {
#ifndef NOKVERBS
if (IS_KVERB(keymap[i])) {
for (j = 0; j < nkverbs; j++)
if (kverbs[j].kwval == (keymap[i] & ~F_KVERB))
break;
if (j != nkverbs) {
#ifdef OS2
sprintf(buf, "set key \%d \K%st; %s",
mskkeys ? cktomsk(i) : i,
kverbs[j].kwd, keyname(i)
);
zsoutl(ZMFILE,buf);
#else
sprintf(buf, "set key \%d \K%s", i, kverbs[j].kwd);
zsoutl(ZMFILE,buf);
#endif
}
} else
#endif /* NOKVERBS */
{
#ifdef OS2
sprintf(buf, "set key \%d \{%d}t; %s",
mskkeys ? cktomsk(i) : i,
keymap[i],
keyname(i)
);
zsoutl(ZMFILE,buf);
#else
sprintf(buf, "set key \%d \{%d}", i, keymap[i]);
zsoutl(ZMFILE,buf);
#endif /* OS2 */
}
}
}
#ifdef OS2
/* OS/2 also has the SET TERMINAL KEY <termtype> defines */
for (k = 0; k < nttkey; k++) {
extern struct keynode * ttkeymap[];
struct keynode * pnode = NULL;
if (ttkeytab[k].flgs) /* Don't process CM_INV or CM_ABR */
continue;
zsoutl(ZMFILE,"");
sprintf(buf, "; SET TERMINAL KEY %s", ttkeytab[k].kwd );
zsoutl(ZMFILE,buf);
for (pnode = ttkeymap[ttkeytab[k].kwval];
pnode;
pnode = pnode->next
) {
switch (pnode->def.type) {
case key:
sprintf(buf, "set terminal key %s \%d \{%d}t; %s",
ttkeytab[k].kwd,
mskkeys ? cktomsk(pnode->key) : pnode->key,
pnode->def.key.scancode,
keyname(pnode->key)
);
zsoutl(ZMFILE,buf);
break;
case kverb:
for (j = 0; j < nkverbs; j++)
if (kverbs[j].kwval == (pnode->def.kverb.id & ~F_KVERB))
break;
if (j != nkverbs) {
sprintf(buf, "set terminal key %s \%d \K%st; %s",
ttkeytab[k].kwd,
mskkeys ? cktomsk(pnode->key) : pnode->key,
kverbs[j].kwd, keyname(pnode->key)
);
zsoutl(ZMFILE,buf);
}
break;
case macro: {
int len = strlen((char *)pnode->def.macro.string);
sprintf(buf,"set terminal key %s \%d ",
ttkeytab[k].kwd,
mskkeys ? cktomsk(pnode->key) : pnode->key);
zsout(ZMFILE,buf);
for (j = 0; j < len; j++) {
char ch = pnode->def.macro.string[j];
if (ch <= SP || ch >= DEL ||
ch == '-' || ch == ',' ||
ch == '{' || ch == '}' ||
ch == ';' || ch == '?' ||
ch == '.' || ch == ''' ||
ch == '\' || ch == '/' ||
ch == '#') {
sprintf(buf, "\{%d}", ch);
zsout(ZMFILE,buf);
} else {
sprintf(buf, "%c", ch);
zsout(ZMFILE,buf);
}
}
sprintf(buf, "t; %s", keyname(pnode->key));
zsoutl(ZMFILE,buf);
break;
}
case literal: {
int len = strlen((char *)pnode->def.literal.string);
sprintf(buf,"set terminal key %s /literal \%d ",
ttkeytab[k].kwd,
mskkeys ? cktomsk(pnode->key) : pnode->key);
zsout(ZMFILE,buf);
for (j = 0; j < len; j++) {
char ch = pnode->def.literal.string[j];
if (ch <= SP || ch >= DEL ||
ch == '-' || ch == ',' ||
ch == '{' || ch == '}' ||
ch == ';' || ch == '?' ||
ch == '.' || ch == ''' ||
ch == '\' || ch == '/' ||
ch == '#') {
sprintf(buf, "\{%d}", ch);
zsout(ZMFILE,buf);
} else {
sprintf(buf, "%c", ch);
zsout(ZMFILE,buf);
}
}
sprintf(buf, "t; %s", keyname(pnode->key));
zsoutl(ZMFILE,buf);
break;
}
case esc:
sprintf(buf,
"set terminal key %s /literal \%d \{%d}\{%d}t; %s",
ttkeytab[k].kwd,
mskkeys ? cktomsk(pnode->key) : pnode->key,
ISDG200(ttkeytab[k].kwval) ? 30 : 27,
pnode->def.esc.key & ~F_ESC,
keyname(pnode->key)
);
zsoutl(ZMFILE,buf);
break;
case csi:
sprintf(buf,
"set terminal key %s /literal \%d \{27}[\{%d}t; %s",
ttkeytab[k].kwd,
mskkeys ? cktomsk(pnode->key) : pnode->key,
pnode->def.csi.key & ~F_CSI,
keyname(pnode->key)
);
zsoutl(ZMFILE,buf);
break;
default:
continue;
}
}
}
#endif /* OS2 */
zsoutl(ZMFILE,"");
zsoutl(ZMFILE,"; End");
zclose(ZMFILE);
return(success = 1);
} else {
return(success = 0);
}
}
#endif /* NOSETKEY */
#ifdef OS2
struct keytab cmdtrmopt[] = {
"scrollback", 0, 0
};
_PROTOTYP(int savscrbk, (int, char *, int));
#endif /* OS2 */
int
dosave(xx) int xx; {
int x, y, disp;
char * s = NULL;
extern struct keytab disptb[];
#ifdef ZFNQFP
struct zfnfp * fnp;
#endif /* ZFNQFP */
switch (xx) {
#ifdef OS2
case XSCMD:
case XSTERM:
if ((y = cmkey(cmdtrmopt,1,"What to save","scrollback",xxstring)) < 0)
return(y);
z = cmofi("Name of Scrollback file","scrollbk.txt",&s,xxstring);
if (z < 0) return(z);
if (z == 2) {
printf("?Sorry, %s is a directory namen",s);
return(-9);
}
#ifdef ZFNQFP
if (fnp = zfnqfp(s,TMPBUFSIZ - 1,tmpbuf)) {
if (fnp->fpath)
if ((int) strlen(fnp->fpath) > 0)
s = fnp->fpath;
}
#endif /* ZFNQFP */
strcpy(line,s);
s = line;
#ifdef MAC
z = 0;
#else
if ((z = cmkey(disptb,2,"Disposition","new",xxstring)) < 0)
return(z);
#endif /* MAC */
disp = z;
if ((x = cmcfm()) < 0) return(x);
switch (xx) {
case XSCMD:
return(success = savscrbk(VCMD,s,disp));
case XSTERM:
return(success = savscrbk(VTERM,s,disp));
default:
return(success = 0);
}
#endif /* OS2 */
#ifndef NOSETKEY
case XSKEY:
y = cmofi("Name of Kermit command file","keymap.ksc",&s,xxstring);
if (y < 0) return(y);
if (y == 2) {
printf("?Sorry, %s is a directory namen",s);
return(-9);
}
#ifdef ZFNQFP
if (fnp = zfnqfp(s,TMPBUFSIZ - 1,tmpbuf)) {
if (fnp->fpath)
if ((int) strlen(fnp->fpath) > 0)
s = fnp->fpath;
}
#endif /* ZFNQFP */
strcpy(line,s);
s = line;
#ifdef MAC
y = 0;
#else
if ((y = cmkey(disptb,2,"Disposition","new",xxstring)) < 0)
return(y);
#endif /* MAC */
disp = y;
if ((x = cmcfm()) < 0) return(x);
return (savkeys(s,disp));
#endif /* NOSETKEY */
default:
if ((x = cmcfm()) < 0) return(x);
printf("Not implemented - %sn",cmdbuf);
return(success = 0);
}
}
/*
R E A D T E X T
Read text with a custom prompt into given buffer using command parser but
with no echoing or entry into recall buffer.
*/
int
readtext(prmpt, buffer, bufsiz) char * prmpt; char * buffer; int bufsiz; {
#ifdef CK_RECALL
int sv_recall; /* For turning off command recall */
extern int on_recall; /* around Password prompting */
#endif /* CK_RECALL */
int rc;
#ifdef OS2
extern int vmode;
int vmode_sav = vmode;
if (win95_popup
#ifdef IKSD
&& !inserver
#endif /* IKSD */
)
return(popup_readtext(vmode,prmpt,buffer,bufsiz,0));
if (vmode == VTERM) {
vmode = VCMD;
VscrnIsDirty(VTERM);
VscrnIsDirty(VCMD);
}
#endif /* OS2 */
#ifdef CK_RECALL
sv_recall = on_recall; /* Save and turn off command recall */
on_recall = 0;
#endif /* CK_RECALL */
cmsavp(psave,PROMPTL); /* Save old prompt */
cmsetp(prmpt); /* Make new prompt */
concb((char)escape); /* Put console in cbreak mode */
cmini(1); /* and echo mode */
if (pflag) prompt(xxstring); /* Issue prompt if at top level */
cmres(); /* Reset the parser */
for (rc = -1; rc < 0; ) { /* Prompt till they answer */
rc = cmtxt("","",&s,NULL); /* Get a literal line of text */
cmres(); /* Reset the parser again */
}
ckstrncpy(buffer,s,bufsiz);
#ifdef CK_RECALL
on_recall = sv_recall; /* Restore command recall */
#endif /* CK_RECALL */
cmsetp(psave); /* Restore original prompt */
#ifdef OS2
if (vmode != vmode_sav) {
vmode = VTERM;
VscrnIsDirty(VCMD);
VscrnIsDirty(VTERM);
}
#endif /* OS2 */
return(0);
}
#endif /* NOICP */
/* A general function to allow a Password or other information */
/* to be read from the command prompt without it going into */
/* the recall buffer or being echo'd. */
int
readpass(prmpt, buffer, bufsiz) char * prmpt; char * buffer; int bufsiz; {
#ifdef NOICP
printf("%s", prmpt);
gets(buffer);
return(1);
#else /* NOICP */
#ifdef CK_RECALL
int sv_recall; /* For turning off command recall */
extern int on_recall; /* around Password prompting */
#endif /* CK_RECALL */
int rc;
#ifdef OS2
extern int vmode;
int vmode_sav = vmode;
#endif /* OS2 */
#ifdef CKSYSLOG
int savlog;
#endif /* CKSYSLOG */
#ifdef OS2
if (win95_popup
#ifdef IKSD
&& !inserver
#endif /* IKSD */
)
return(popup_readpass(vmode,prmpt,buffer,bufsiz,0));
#endif /* OS2 */
#ifdef CKSYSLOG
savlog = ckxsyslog; /* Save and turn off syslogging */
ckxsyslog = 0;
#endif /* CKSYSLOG */
#ifdef OS2
if (vmode == VTERM) {
vmode = VCMD;
VscrnIsDirty(VTERM);
VscrnIsDirty(VCMD);
}
#endif /* OS2 */
#ifdef CK_RECALL
sv_recall = on_recall; /* Save and turn off command recall */
on_recall = 0;
#endif /* CK_RECALL */
cmsavp(psave,PROMPTL); /* Save old prompt */
cmsetp(prmpt); /* Make new prompt */
concb((char)escape); /* Put console in cbreak mode */
cmini(0); /* and no-echo mode */
if (pflag) prompt(xxstring); /* Issue prompt if at top level */
cmres(); /* Reset the parser */
for (rc = -1; rc < 0; ) { /* Prompt till they answer */
rc = cmtxt("","",&s,NULL); /* Get a literal line of text */
cmres(); /* Reset the parser again */
}
ckstrncpy(buffer,s,bufsiz);
#ifdef CK_RECALL
on_recall = sv_recall; /* Restore command recall */
#endif /* CK_RECALL */
printf("rn"); /* Echo a CRLF */
cmsetp(psave); /* Restore original prompt */
cmini(1); /* Restore echo mode */
#ifdef OS2
if (vmode != vmode_sav) {
vmode = VTERM;
VscrnIsDirty(VCMD);
VscrnIsDirty(VTERM);
}
#endif /* OS2 */
#ifdef CKSYSLOG
ckxsyslog = savlog; /* Restore syslogging */
#endif /* CKSYSLOG */
return(0);
#endif /* NOICP */
}
#ifndef NOICP
struct keytab authtab[] = { /* Available authentication types */
#ifdef CK_KERBEROS
"k4", AUTH_KRB4, CM_INV,
"k5", AUTH_KRB5, CM_INV,
"kerberos4", AUTH_KRB4, 0,
"kerberos5", AUTH_KRB5, 0,
"krb4", AUTH_KRB4, CM_INV,
"krb5", AUTH_KRB5, CM_INV,
#endif /* CK_KERBEROS */
#ifdef NT
"ntlm", AUTH_NTLM, 0,
#endif /* NT */
#ifdef CK_SRP
"srp", AUTH_SRP, 0,
#endif /* CK_SRP */
#ifdef CK_SSL
"ssl", AUTH_SSL, 0,
#endif /* CK_SSL */
"", 0, 0
};
int authtabn = sizeof(authtab)/sizeof(struct keytab)-1;
#ifdef CK_KERBEROS
struct keytab kerbtab[] = { /* Kerberos authentication types */
"k4", AUTH_KRB4, CM_INV,
"k5", AUTH_KRB5, CM_INV,
"kerberos4", AUTH_KRB4, 0,
"kerberos5", AUTH_KRB5, 0,
"krb4", AUTH_KRB4, CM_INV,
"krb5", AUTH_KRB5, CM_INV
};
int kerbtabn = sizeof(kerbtab)/sizeof(struct keytab);
static struct keytab krb_s_tbl[] = { /* AUTHENTICATE command switches: */
"/cache", KRB_S_CA, CM_ARG
};
static int krb_s_n = sizeof(krb_s_tbl)/sizeof(struct keytab);
static struct keytab krb_v_tbl[] = { /* KERBEROS version values: */
"4", 4, 0,
"5", 5, 0, /* (add others as needed...) */
"auto", 0, 0 /* Note: 0 = auto */
};
static int krb_v_n = sizeof(krb_v_tbl)/sizeof(struct keytab);
static struct keytab krb_a_tbl[] = { /* KERBEROS actions: */
"destroy", KRB_A_DE, 0,
"initialize", KRB_A_IN, 0,
"list-credentials", KRB_A_LC, 0
};
static int krb_a_n = sizeof(krb_a_tbl)/sizeof(struct keytab);
static struct keytab krb4_i_tbl[] = { /* KERBEROS 4 INITIALIZE switches: */
"/brief", KRB_I_BR, 0, /* /BRIEF */
"/instance", KRB_I_IN, CM_ARG, /* /INSTANCE: */
"/lifetime", KRB_I_LF, CM_ARG, /* /LIFETIME: */
"/not-preauth", KRB_I_NPA, 0, /* /NOT-PREAUTH */
"/password", KRB_I_PW, CM_ARG, /* /PASSWORD: */
#ifdef OS2
"/popup", KRB_I_POP, 0, /* /POPUP */
#endif /* OS2 */
"/preauth", KRB_I_PA, 0, /* /PREAUTH */
"/realm", KRB_I_RL, CM_ARG, /* /REALM: */
"/verbose", KRB_I_VB, 0, /* /VERBOSE */
"", 0, 0
};
static int krb4_i_n = sizeof(krb4_i_tbl)/sizeof(struct keytab) - 1;
static struct keytab krb5_i_tbl[] = { /* KERBEROS 5 INITIALIZE switches: */
"/addresses", KRB_I_ADR, CM_ARG,
"/forwardable", KRB_I_FW, 0, /* /FORWARDABLE */
"/instance", KRB_I_IN, CM_ARG, /* /INSTANCE: */
"/k4", KRB_I_K4, CM_INV, /* /KERBEROS4 */
"/kerberos4", KRB_I_K4, 0, /* /KERBEROS4 */
"/krb4", KRB_I_K4, CM_INV, /* /KERBEROS4 */
"/lifetime", KRB_I_LF, CM_ARG, /* /LIFETIME: */
"/no-k4", KRB_I_NK4, CM_INV,/* /NO-KERBEROS4 */
"/no-kerberos4", KRB_I_NK4, 0, /* /NO-KERBEROS4 */
"/no-krb4", KRB_I_NK4, CM_INV,/* /NO-KERBEROS4 */
"/not-forwardable", KRB_I_NFW, 0, /* /NOT-FORWARDABLE */
"/not-proxiable", KRB_I_NPR, 0, /* /NOT-PROXIABLE */
"/password", KRB_I_PW, CM_ARG, /* /PASSWORD: */
#ifdef OS2
"/popup", KRB_I_POP, 0, /* /POPUP */
#endif /* OS2 */
"/postdate", KRB_I_PD, CM_ARG, /* /POSTDATE: */
"/pr", KRB_I_PR, CM_INV|CM_ABR, /* to allow for */
"/pro", KRB_I_PR, CM_INV|CM_ABR, /* different spellings */
"/prox", KRB_I_PR, CM_INV|CM_ABR,
"/proxiable", KRB_I_PR, 0, /* /PROXIABLE */
"/proxyable", KRB_I_PR, CM_INV, /* /PROXYABLE */
"/realm", KRB_I_RL, CM_ARG, /* /REALM: */
"/renew", KRB_I_RN, 0, /* /RENEW */
"/renewable", KRB_I_RB, CM_ARG, /* /RENEWABLE: */
"/service", KRB_I_SR, CM_ARG, /* /SERVICE: */
"/validate", KRB_I_VA, 0, /* /VALIDATE */
"", 0, 0
};
static int krb5_i_n = sizeof(krb5_i_tbl)/sizeof(struct keytab) - 1;
static struct keytab klctab[] = { /* List Credentials switches*/
"/addresses", XYKLCAD, 0,
"/encryption", XYKLCEN, 0,
"/flags", XYKLCFL, 0
};
static int nklctab = sizeof(klctab)/sizeof(struct keytab);
extern int krb_action;
extern struct krb_op_data krb_op;
extern struct krb5_list_cred_data krb5_lc;
extern struct krb5_init_data krb5_init;
extern char * krb5_d_principal; /* Default principal */
extern char * krb5_d_instance;
extern char * krb5_d_realm; /* Default realm */
extern char * krb5_d_cc; /* Default credentials cache */
extern char * krb5_d_srv; /* Default service name */
extern int krb5_d_lifetime; /* Default lifetime */
extern int krb5_d_forwardable;
extern int krb5_d_proxiable;
extern int krb5_d_renewable;
extern int krb5_autoget;
extern int krb5_autodel;
extern int krb5_d_getk4;
extern int krb5_checkaddrs;
extern struct krb4_init_data krb4_init;
extern char * krb4_d_principal; /* Default principal */
extern char * krb4_d_realm; /* Default realm */
extern char * krb4_d_srv; /* Default service name */
extern int krb4_d_lifetime; /* Default lifetime */
extern int krb4_d_preauth;
extern char * krb4_d_instance;
extern int krb4_autoget;
extern int krb4_autodel;
extern int krb4_checkaddrs;
#endif /* CK_KERBEROS */
#ifndef NOSHOW
#ifdef CK_AUTHENTICATION
int
sho_auth(cx) int cx; {
extern int auth_type_user[];
int i;
char * p;
int kv = 0, all = 0;
#ifdef IKSD
if (inserver) {
printf("?Sorry, command disabled.rn");
return(success = 0);
}
#endif /* IKSD */
if (cx) {
kv = cx;
} else if (auth_type_user[0] != AUTHTYPE_AUTO) {
kv = auth_type_user[0];
} else {
all = 1;
kv = AUTHTYPE_KERBEROS_V4;
}
while (kv) {
switch (kv) {
case AUTHTYPE_KERBEROS_V4:
kv = all ? AUTHTYPE_KERBEROS_V5 : 0;
if (ck_krb4_is_installed())
printf(" Authentication: Kerberos 4n");
else {
printf(" Authentication: Kerberos 4 (not installed)n");
continue;
}
#ifdef CK_KERBEROS
if (krb_action < 0) {
p = "(none)";
} else {
for (p = "", i = 0; i < krb_a_n; i++) {
if (krb_action == krb_a_tbl[i].kwval) {
p = krb_a_tbl[i].kwd;
break;
}
}
}
printf(" Action: %sn", p);
printf(" Default lifetime %dn",krb4_d_lifetime);
printf(" Lifetime: %d (minutes)n",krb4_init.lifetime);
printf(" Default preauth: %dn",krb4_d_preauth);
printf(" Preauth: %dn",krb4_init.preauth);
printf(" Default principal: "%s"n",
krb4_d_principal ? krb4_d_principal : "");
printf(" Principal: "%s"n",
krb4_init.principal ? krb4_init.principal : "");
printf(" Default realm: "%s"n",
krb4_d_realm ? krb4_d_realm : "");
printf(" Realm: "%s"n",
krb4_init.realm ? krb4_init.realm : "");
printf(" Default instance: "%s"n",
krb4_d_instance ? krb4_d_instance : "");
printf(" Instance: "%s"n",
krb4_init.instance ? krb4_init.instance : "");
printf(" Auto-Get TGTs: %dn",krb4_autoget);
printf(" Auto-Destroy TGTs: %sn",
krb4_autodel==KRB_DEL_NO?"never":
krb4_autodel==KRB_DEL_CL?"on-close":"on-exit");
printf(" Check IP Addresses: %dn",krb4_checkaddrs);
#ifdef COMMENT
printf(" Password: "%s"n",
krb4_init.password ? krb4_init.password : "");
#endif /* COMMENT */
#endif /* CK_KERBEROS */
printf("n");
break;
case AUTHTYPE_KERBEROS_V5:
kv = all ? AUTHTYPE_SSL : 0;
if (ck_krb5_is_installed())
printf(" Authentication: Kerberos 5n");
else {
printf(" Authentication: Kerberos 5 (not installed)n");
continue;
}
#ifdef CK_KERBEROS
printf(" Cache file: %sn",
krb_op.cache ? krb_op.cache : "(none)");
printf(" Default cache: %sn",
krb5_d_cc ? krb5_d_cc : "(none)");
if (krb_action < 0) {
p = "(none)";
} else {
for (p = "", i = 0; i < krb_a_n; i++) {
if (krb_action == krb_a_tbl[i].kwval) {
p = krb_a_tbl[i].kwd;
break;
}
}
}
printf(" Action: %sn", p);
printf(" Default forwardable %dn",krb5_d_forwardable);
printf(" Forwardable: %dn",krb5_init.forwardable);
printf(" Default lifetime %dn",krb5_d_lifetime);
printf(" Lifetime: %d (minutes)n",krb5_init.lifetime);
printf(" Postdate: "%s"n",
krb5_init.postdate ? krb5_init.postdate: "");
printf(" Default proxiable: %dn",krb5_d_proxiable);
printf(" Proxiable: %dn",krb5_init.proxiable);
printf(" Renew: %dn",krb5_init.renew);
printf(" Default renewable: %d (minutes)n",krb5_d_renewable);
printf(" Renewable: %d (minutes)n",krb5_init.renewable);
printf(" Service: "%s"n",
krb5_init.service ? krb5_init.service : "");
printf(" Validate: %dn",krb5_init.validate);
printf(" Default principal: "%s"n",
krb5_d_principal ? krb5_d_principal : "");
printf(" Principal: "%s"n",
krb5_init.principal ? krb5_init.principal : "");
printf(" Default instance: "%s"n",
krb5_d_instance ? krb5_d_instance : "");
printf(" Default realm: "%s"n",
krb5_d_realm ? krb5_d_realm : "");
printf(" Realm: "%s"n",
krb5_init.realm ? krb5_init.realm : "");
printf(" Auto-Get TGTs: %dn",krb5_autoget);
printf(" Auto-Destroy TGTs: %sn",
krb5_autodel==KRB_DEL_NO?"never":
krb5_autodel==KRB_DEL_CL?"on-close":"on-exit");
printf(" Default get K4 TGTs: %dn",krb5_d_getk4);
printf(" Get K4 TGTs: %dn",krb5_init.getk4);
printf(" Check IP Addresses: %dn",krb5_checkaddrs);
printf(" IP-Addresses: ");
if (krb5_init.addrs) {
for (i = 0; krb5_init.addrs[i]; i++) {
if (i)
printf(",");
printf("%s",krb5_init.addrs[i]);
}
printf("n");
} else
printf("(use default)n");
#ifdef COMMENT
printf(" Password: "%s"n",
krb5_init.password ? krb5_init.password : "");
#endif /* COMMENT */
#endif /* CK_KERBEROS */
printf("n");
break;
case AUTHTYPE_SSL:
kv = 0;
if (ck_ssleay_is_installed())
printf(" Authentication: SSL/TLSn");
else {
printf(" Authentication: SSL/TLS (not installed)n");
continue;
}
#ifdef CK_SSL
printf(" RSA Certs file: %sn",ssl_rsa_cert_file?
ssl_rsa_cert_file:"(none)");
printf(" RSA Key file: %sn",ssl_rsa_key_file?
ssl_rsa_key_file:"(none)");
printf(" DSA Certs file: %sn",ssl_dsa_cert_file?
ssl_dsa_cert_file:"(none)");
printf(" DH Key file: %sn",ssl_dh_key_file?
ssl_dh_key_file:"(none)");
printf(" DH Param file: %sn",ssl_dh_param_file?
ssl_dh_param_file:"(none)");
printf(" CRL file: %sn",ssl_crl_file?
ssl_crl_file:"(none)");
printf(" CRL dir: %sn",ssl_crl_dir?
ssl_crl_dir:"(none)");
printf(" Verify file: %sn",ssl_verify_file?
ssl_verify_file:"(none)");
printf(" Verify dir: %sn",ssl_verify_dir?
ssl_verify_dir:"(none)");
printf(" Cipher list:n");
if (ssl_con == NULL) {
SSL_library_init();
ssl_ctx = (SSL_CTX *)
SSL_CTX_new((SSL_METHOD *)TLSv1_method());
if (ssl_ctx != NULL)
ssl_con= (SSL *) SSL_new(ssl_ctx);
}
if (ssl_con != NULL) {
CHAR * p = NULL;
int i;
for (i = 0; ; i++) {
p = (CHAR *) SSL_get_cipher_list(ssl_con,i);
if (p == NULL)
break;
printf(" %sn",p);
}
}
printf(" Certs OK? %sn",ssl_certsok_flag? "yes" : "no");
printf(" Debug mode: %sn", ssl_debug_flag ? "on" : "off");
printf(" Verbose mode: %sn", ssl_verbose_flag ? "on" : "off");
printf(" Verify mode: %sn",
ssl_verify_flag == SSL_VERIFY_NONE ? "none" :
ssl_verify_flag == SSL_VERIFY_PEER ? "peer-cert" :
"fail-if-no-peer-cert");
printf(" SSL only? %sn", ssl_only_flag ? "yes" : "no");
printf(" TLS only? %sn", tls_only_flag ? "yes" : "no");
#endif /* CK_SSL */
break;
case AUTHTYPE_NTLM:
kv = 0;
if (ck_ntlm_is_installed()) {
printf(" Authentication: NTLMn");
printf(" No optionsn");
} else {
printf(" Authentication: NTLM (not installed)n");
continue;
}
printf("n");
break;
case AUTHTYPE_SRP:
kv = 0;
if (ck_srp_is_installed()) {
printf(" Authentication: SRPn");
printf(" No optionsn");
} else {
printf(" Authentication: SRP (not installed)n");
continue;
}
printf("n");
break;
}
}
return(success = 1);
}
#endif /* CK_AUTHENTICATION */
#endif /* NOSHOW */
#ifdef CK_KERBEROS
/* C P _ A U T H -- AUTHENTICATE command parsing */
int
cp_auth() { /* Command_Parse AUTHENTICATE */
int c, i, n; /* Workers */
int rc = 0; /* Return code */
int getval; /* Parsing helpers */
int tmpauth = 0; /* Temporary authentication type */
int kv = 0; /* Temporary Kerberos version */
int tmp_action = -1; /* Temporary Kerberos action */
int tmp_klc = 0; /* Temporary list-credentials */
char tmphlp[256]; /* For building help message */
char * p;
char * tmppswd = NULL; /* Password */
char * tmpprinz = NULL; /* Principal */
char * tmprealm = NULL; /* Realm */
char * tmpcache = NULL; /* Cache file */
char * tmpinst = NULL; /* K4 Instance */
char * tmpaddrs[KRB5_NUM_OF_ADDRS];
#ifdef CK_RECALL
int sv_recall; /* For turning off command recall */
extern int on_recall; /* around Password prompting */
#endif /* CK_RECALL */
struct stringint { /* Temporary array for switch values */
char * sval; /* String value */
int ival; /* Integer value */
} pv[KRB_I_MAX+1]; /* This many */
struct FDB kw, sw, fl; /* FDBs for each parse function */
krb_action = -1; /* Initialize Kerberos action. */
tmp_action = -1; /* And our local copy. */
for (i = 0; i < KRB5_NUM_OF_ADDRS; i++)
tmpaddrs[i] = NULL;
if ((y = cmkey(kerbtab,kerbtabn,"authentication type","",xxstring)) < 0)
{
if (y == -3)
printf("?Authentication type not specified - nothing happensn");
return(y);
}
tmpauth = y;
debug(F101,"kerberos authentication","",tmpauth);
switch (tmpauth) {
case AUTH_KRB4: kv = 4; break; /* Don't assume values are the same */
case AUTH_KRB5: kv = 5; break;
default:
printf("?Authentication type not supported: "%s"n",atmbuf);
return(-9);
}
/* From here down is Kerberos */
ini_kerb(); /* Reset Init data to defaults */
if (kv == 4) { /* Set K4 defaults */
if (krb4_d_realm)
makestr(&tmprealm,krb4_d_realm);
if (krb4_d_principal)
makestr(&tmpprinz,krb4_d_principal);
if (krb4_d_instance)
makestr(&tmpinst,krb4_d_instance);
} else if (kv == 5) { /* Set K5 defaults */
if (krb5_d_cc)
makestr(&tmpcache,krb5_d_cc);
if (krb5_d_realm)
makestr(&tmprealm,krb5_d_realm);
if (krb5_d_principal)
makestr(&tmpprinz,krb5_d_principal);
if (krb5_d_instance)
makestr(&tmpinst,krb5_d_instance);
}
for (i = 0; i <= KRB_I_MAX; i++) { /* Initialize switch values */
pv[i].sval = NULL; /* to null pointers */
pv[i].ival = 0; /* and 0 int values */
}
if (kv == 4) { /* Kerberos 4 */
pv[KRB_I_LF].ival = krb4_d_lifetime;
pv[KRB_I_PA].ival = krb4_d_preauth;
if ((n = cmkey(krb_a_tbl,krb_a_n,"Kerberos 4 action","",xxstring)) < 0)
{
if (n == -3)
printf("?Action not specified - nothing happens.n");
return(n);
}
} else if (kv == 5) { /* Kerberos 5 */
pv[KRB_I_FW].ival = krb5_d_forwardable;
pv[KRB_I_PR].ival = krb5_d_proxiable;
pv[KRB_I_LF].ival = krb5_d_lifetime;
pv[KRB_I_RB].ival = krb5_d_renewable;
pv[KRB_I_K4].ival = krb5_d_getk4;
/* Make help message that shows switches and action keywords */
strcpy(tmphlp,"Kerberos 5 action, one of the following:n ");
for (i = 0; i < krb_a_n; i++) {
strcat(tmphlp,krb_a_tbl[i].kwd);
if (i == krb_a_n - 1)
strcat(tmphlp,"nor switch");
else
strcat(tmphlp," ");
}
/* Set up first set of chained FDB's */
cmfdbi(&sw, /* First FDB - command switches */
_CMKEY, /* fcode */
tmphlp, /* hlpmsg */
"", /* default (none) */
"", /* addtl string data */
krb_s_n, /* Switch table size */
4, /* addtl numeric data 2: 4 = cmswi */
xxstring, /* Processing function */
krb_s_tbl, /* Switch table */
&kw /* Pointer to next FDB */
);
cmfdbi(&kw, /* Second FDB - action keywords */
_CMKEY, /* fcode */
"Kerberos action", /* hlpmsg */
"", /* default (none) */
"", /* addtl string data */
krb_a_n, /* Switch table size */
0, /* addtl num data (0 = NOT switch) */
xxstring, /* Processing function */
krb_a_tbl, /* Keyword table */
NULL /* Pointer to next FDB (none) */
);
/* Parse */
while (1) { /* Parse 0 or more switches */
rc = cmfdb(&sw); /* Parse something */
debug(F101,"kerberos cmfdb 1 rc","",rc);
if (rc < 0) { /* Error */
if (rc == -3)
printf("?Action not specified - nothing happens.n");
return(rc); /* or reparse needed */
}
if (cmresult.fdbaddr != &sw) /* Break out if not a switch */
break;
c = cmgbrk(); /* Have switch - get break character */
getval = (c == ':' || c == '='); /* Must parse an agument? */
if (getval && !(cmresult.kflags & CM_ARG)) {
printf("?This switch does not take argumentsn");
return(-9); /* OK because nothing malloc'd yet */
}
if (!getval && (cmgkwflgs() & CM_ARG)) {
printf("?This switch requires an argumentn");
return(-9);
}
n = cmresult.nresult; /* Numeric result = switch value */
debug(F101,"kerberos command switch","",n);
switch (n) { /* Handle the switch */
case KRB_S_CA: /* /CACHE:<filename> */
p = krb5_d_cc ? krb5_d_cc : "";
if ((y = cmofi("Name of cache file",p,&s,xxstring)) < 0) {
if (y == -3)
s = NULL;
else
return(y);
}
makestr(&tmpcache,s);
break;
default:
printf("?Unexpected switch value - internal errorn");
return(-9); /* (if) nothing malloc'd yet. */
}
}
if (cmresult.fdbaddr != &kw) { /* Checking... */
printf("?Unexpected result - internal errorn");
return(-9); /* Nothing malloc'd yet. */
}
n = cmresult.nresult; /* Get keyword value */
} else {
printf("?Unexpected Kerberos version - Internal errorn");
return(-9);
}
debug(F101,"kerberos action","",n);
switch (n) {
case KRB_A_IN: /* INITIALIZE */
case KRB_A_DE: /* DESTROY */
case KRB_A_LC: /* LIST-CREDENTIALS */
tmp_action = n; /* OK, set */
break;
default: /* Not OK, punt. */
printf("?Unexpected action - internal errorn");
return(-9);
}
if (tmp_action == KRB_A_IN) { /* Action is INITIALIZE */
int x;
cmfdbi(&sw, /* INITIALIZE switches */
_CMKEY, /* fcode */
"Principal,n or optional INITIALIZE switch(es)", /* hlpmsg */
"", /* default (none) */
"", /* addtl string data */
kv == 4 ? krb4_i_n : krb5_i_n, /* Switch table size */
4, /* addtl numeric data 2: 4 = cmswi */
xxstring, /* Processing function */
kv == 4 ? krb4_i_tbl : krb5_i_tbl, /* Switch table */
&fl /* Pointer to next FDB */
);
cmfdbi(&fl, /* 3rd FDB - command to send from */
_CMFLD, /* fcode */
"Principal", /* hlpmsg */
kv == 4 ? krb4_d_principal : krb5_d_principal, /* principal */
"", /* addtl string data */
0, /* addtl numeric data 1 */
0, /* addtl numeric data 2 */
xxstring,
NULL,
NULL
);
while (1) { /* Parse INIT switches or principal */
rc = cmfdb(&sw);
debug(F101,"kerberos cmfdb 2 rc","",rc);
if (rc < 0) {
if (rc == -3)
printf("?Principal name requiredn");
goto kerbx;
}
debug(F101,"kerberos cmfdb 2 fcode","",cmresult.fcode);
if (cmresult.fcode != _CMKEY) /* Not a switch, quit switch loop */
break;
c = cmgbrk(); /* Switch - get break character */
debug(F101,"kerberos cmfdb 2 cmgbrk","",c);
getval = (c == ':' || c == '=');
if (getval && !(cmresult.kflags & CM_ARG)) {
printf("?This switch does not take argumentsn");
return(-9); /* OK because nothing malloc'd yet */
}
if (!getval && (cmgkwflgs() & CM_ARG)) {
printf("?This switch requires an argumentn");
return(-9);
}
n = cmresult.nresult; /* Numeric result = switch value */
switch (n) {
/* These don't take args... */
case KRB_I_PA: /* /PREAUTH */
case KRB_I_FW: /* /FORWARDABLE */
case KRB_I_PR: /* /PROXIABLE */
case KRB_I_RN: /* /RENEW */
case KRB_I_VA: /* /VALIDATE */
case KRB_I_NPA: /* /NOT-PREAUTH */
case KRB_I_NFW: /* /NOT-FORWARDABLE */
case KRB_I_NPR: /* /NOT-PROXIABLE */
case KRB_I_VB: /* /VERBOSE */
case KRB_I_BR: /* /BRIEF */
case KRB_I_K4: /* /KERBEROS4 */
case KRB_I_NK4: /* /NO-KERBEROS4 */
case KRB_I_POP: /* /POPUP */
if (getval) {
printf("?This switch does not take a valuen");
rc = -9;
goto kerbx;
}
switch (n) {
case KRB_I_NPA:
pv[KRB_I_PA].ival = 0;
break;
case KRB_I_NFW:
pv[KRB_I_FW].ival = 0;
break;
case KRB_I_NPR:
pv[KRB_I_PR].ival = 0;
break;
case KRB_I_VB:
pv[KRB_I_BR].ival = 0;
break;
case KRB_I_NK4:
pv[KRB_I_K4].ival = 0;
break;
default:
pv[n].ival = 1;
}
break;
/* These do take arguments */
case KRB_I_RB: /* /RENEWABLE:<minutes> */
pv[n].ival = 0;
if (!getval) break;
if ((rc = cmnum("Minutes",ckitoa(krb5_init.renewable),
10,&y, xxstring)) < 0)
goto kerbx;
pv[n].ival = y;
break;
case KRB_I_LF: /* /LIFETIME:<minutes> */
pv[n].ival = 0;
sprintf(tmpbuf,"%d", /* Default is previous value */
kv == 4 ?
krb4_init.lifetime :
krb5_init.lifetime
);
if (!getval) break;
if ((rc = cmnum("Minutes",tmpbuf,10,&y, xxstring)) < 0)
goto kerbx;
pv[n].ival = y;
break;
case KRB_I_PD: /* /POSTDATE:<timestamp> */
if (pv[n].sval) {
free(pv[n].sval);
pv[n].sval = NULL;
}
if (!getval) break;
if ((rc = cmdate("date-time","",&s,0,xxstring)) < 0)
goto kerbx;
makestr(&(pv[n].sval),s);
break;
case KRB_I_SR: /* /SERVICE:<name> */
if (pv[n].sval) {
free(pv[n].sval);
pv[n].sval = NULL;
}
if (!getval) break;
if ((rc = cmfld("Service-name","",&s,xxstring)) < 0)
goto kerbx;
makestr(&(pv[n].sval),s);
break;
case KRB_I_RL: /* /REALM:<name> */
if (pv[n].sval) {
free(pv[n].sval);
pv[n].sval = NULL;
}
if (!getval) break;
if (kv == 4)
p = krb4_d_realm ? krb4_d_realm : "";
else
p = krb5_d_realm ? krb5_d_realm : "";
if ((rc = cmfld("Realm",p,&s,xxstring)) < 0)
goto kerbx;
makestr(&(pv[n].sval),s);
break;
case KRB_I_IN: /* /INSTANCE:<name> */
if (pv[n].sval) {
free(pv[n].sval);
pv[n].sval = NULL;
}
if (!getval) break;
if (kv == 4)
p = krb4_d_instance ? krb4_d_instance : "";
else
p = krb5_d_instance ? krb5_d_instance : "";
if ((rc = cmfld("Instance",p,&s,xxstring)) < 0)
goto kerbx;
makestr(&(pv[n].sval),s);
break;
case KRB_I_PW: /* /PASSWORD:<password> */
if (pv[n].sval) {
free(pv[n].sval);
pv[n].sval = NULL;
}
if (!getval) break;
if ((rc = cmfld("Password","",&s,xxstring)) < 0)
goto kerbx;
makestr(&(pv[n].sval),s);
break;
case KRB_I_ADR: /* /ADDRESSES:{<address-list>} */
if (pv[n].sval) {
free(pv[n].sval);
pv[n].sval = NULL;
}
if (!getval) break;
if ((rc = cmfld("List of IP addresses","",&s,xxstring)) < 0)
goto kerbx;
makelist(s,tmpaddrs,KRB5_NUM_OF_ADDRS);
for (i = 0; i < KRB5_NUM_OF_ADDRS && tmpaddrs[i]; i++) {
if (inet_addr(tmpaddrs[i]) == 0xffffffff) {
printf("invalid ip address: %sn",tmpaddrs[i]);
rc = -9;
goto kerbx;
}
}
break;
default:
printf("?Unexpected switch value - internal errorn");
rc = -9;
goto kerbx;
}
}
if (cmresult.fcode != _CMFLD) {
printf("?Unexected result - internal errorn");
rc = -9;
goto kerbx;
}
/* cmresult.sresult may be of the form PRINCIPAL@REALM */
i = ckindex("@",cmresult.sresult,0,0,0);
if (i != 0) {
makestr(&tmprealm,&cmresult.sresult[i]);
cmresult.sresult[i-1] = '';
}
makestr(&tmpprinz,cmresult.sresult); /* Principal (user) */
if ((rc = cmcfm()) < 0) { /* Now get confirmation */
if (rc == -3) {
#ifdef IKSD
if (inserver) {
printf("?Sorry, command disabledrn");
return(success = 0);
}
#endif /* IKSD */
printf("?Principal name requiredn");
}
goto kerbx;
}
#ifdef IKSD
if (inserver) {
printf("?Sorry, command disabledrn");
return(success = 0);
}
#endif /* IKSD */
if (!tmpprinz || !tmpprinz[0]) {
printf("?Principal name requiredn");
goto kerbx;
}
if (!pv[KRB_I_RN].ival && !pv[KRB_I_VA].ival) {
/* Don't use a password if Validating or Renewing */
if (pv[KRB_I_PW].sval) { /* If they gave a /PASSWORD switch */
makestr(&tmppswd,pv[KRB_I_PW].sval); /* use this value */
} else { /* Otherwise must prompt for it */
char prmpt[80];
if (pv[KRB_I_RL].sval)
sprintf(prmpt,"%s@%s's Password: ",
tmpprinz,pv[KRB_I_RL].sval);
else if (tmprealm)
sprintf(prmpt,"%s@%s's Password: ",
tmpprinz,tmprealm);
else
sprintf(prmpt,"%s's Password: ",tmpprinz);
#ifdef OS2
if (pv[KRB_I_POP].ival) {
char passwd[80]="";
readpass(prmpt,passwd,80);
makestr(&tmppswd,passwd);
memset(passwd,0,80);
} else {
#endif /* OS2 */
#ifdef CK_RECALL
sv_recall = on_recall; /* Save & turn off command recall */
on_recall = 0;
#endif /* CK_RECALL */
cmsavp(psave,PROMPTL); /* Save old prompt */
cmsetp(prmpt); /* Make new prompt */
concb((char)escape); /* Put console in cbreak mode */
cmini(0); /* and no-echo mode */
/* Issue prompt if at top level */
if (pflag) prompt(xxstring);
cmres(); /* Reset the parser */
for (rc = -1; rc < 0; ) { /* Prompt till they answer */
/* Get a literal line of text */
rc = cmtxt("","",&s,NULL);
cmres(); /* Reset the parser again */
}
makestr(&tmppswd,s);
#ifdef CK_RECALL
on_recall = sv_recall; /* Restore command recall */
#endif /* CK_RECALL */
printf("n"); /* Echo a CRLF */
cmsetp(psave); /* Restore original prompt */
#ifdef OS2
}
#endif /* OS2 */
}
x = 0; /* Check for password */
if (tmppswd)
if (*tmppswd)
x = 1;
if (!x) {
printf("?Password requiredn");
goto kerbx;
}
}
} else if (kv == 5 && tmp_action == KRB_A_LC) { /* LIST-CREDENTIALS */
tmp_klc = 0;
while (1) {
if ((x = cmkey(klctab,nklctab,"Switch","",xxstring)) < 0) {
if (x == -3) {
if ((rc = cmcfm()) < 0)
goto kerbx;
else
break;
} else {
rc = x;
goto kerbx;
}
}
tmp_klc |= x;
}
} else if ((rc = cmcfm()) < 0) /* DESTROY, just confirm */
goto kerbx;
/* Done - Move confirmed data to final locations */
krb_action = tmp_action; /* Action requested */
krb_op.version = kv; /* Kerberos version */
krb_op.cache = tmpcache; /* Cache file */
tmpcache = NULL; /* So we don't free it */
switch (krb_action) {
case KRB_A_IN: /* INITIALIZE */
if (kv == 5) {
krb5_init.forwardable = pv[KRB_I_FW].ival;
krb5_init.proxiable = pv[KRB_I_PR].ival;
krb5_init.lifetime = pv[KRB_I_LF].ival;
krb5_init.renew = pv[KRB_I_RN].ival;
krb5_init.renewable = pv[KRB_I_RB].ival;
krb5_init.validate = pv[KRB_I_VA].ival;
/* Here we just reassign the pointers and then set them to NULL */
/* so they won't be freed below. */
krb5_init.postdate = pv[KRB_I_PD].sval; pv[KRB_I_PD].sval = NULL;
krb5_init.service = pv[KRB_I_SR].sval; pv[KRB_I_SR].sval = NULL;
if (pv[KRB_I_RL].sval) {
krb5_init.realm = pv[KRB_I_RL].sval; pv[KRB_I_RL].sval = NULL;
} else if (tmprealm) {
krb5_init.realm = tmprealm; tmprealm = NULL;
}
if (pv[KRB_I_IN].sval) {
krb5_init.instance = pv[KRB_I_IN].sval;
pv[KRB_I_IN].sval = NULL;
} else if ( tmpinst ) {
krb5_init.instance = tmpinst;
tmpinst = NULL;
}
if (tmpprinz) {
krb5_init.principal = tmpprinz;
tmpprinz = NULL;
}
krb5_init.password = tmppswd;
tmppswd = NULL;
krb5_init.getk4 = pv[KRB_I_K4].ival;
if (krb5_init.getk4) {
krb4_init.lifetime = pv[KRB_I_LF].ival;
if (krb5_init.realm)
makestr(&krb4_init.realm,krb5_init.realm);
krb4_init.preauth = krb4_d_preauth;
krb4_init.verbose = pv[KRB_I_BR].ival ? 0 : 1;
if (krb5_init.principal)
makestr(&krb4_init.principal,krb5_init.principal);
if (krb5_init.principal)
makestr(&krb4_init.password,krb5_init.password);
}
for (i = 0; i < KRB5_NUM_OF_ADDRS; i++) {
krb5_init.addrs[i] = tmpaddrs[i];
tmpaddrs[i] = NULL;
}
} else if (kv == 4) { /* Same deal for Kerberos 4 */
krb4_init.lifetime = pv[KRB_I_LF].ival;
if (pv[KRB_I_RL].sval) {
krb4_init.realm = pv[KRB_I_RL].sval;
pv[KRB_I_RL].sval = NULL;
} else if ( tmprealm ) {
krb4_init.realm = tmprealm;
tmprealm = NULL;
}
if (pv[KRB_I_IN].sval) {
krb4_init.instance = pv[KRB_I_IN].sval;
pv[KRB_I_IN].sval = NULL;
} else if ( tmpinst ) {
krb4_init.instance = tmpinst;
tmpinst = NULL;
}
krb4_init.preauth = pv[KRB_I_PA].ival;
krb4_init.verbose = pv[KRB_I_BR].ival ? 0 : 1;
if (tmpprinz) {
krb4_init.principal = tmpprinz;
tmpprinz = NULL;
}
krb4_init.password = tmppswd;
tmppswd = NULL;
}
break;
case KRB_A_LC: /* List Credentials */
krb5_lc.encryption = tmp_klc & XYKLCEN;
krb5_lc.flags = tmp_klc & XYKLCFL;
krb5_lc.addr = tmp_klc & XYKLCAD;
break;
}
/* Common exit - Free temporary storage */
kerbx:
for (i = 0; i <= KRB_I_MAX; i++) { /* Free malloc'd switch data */
if (pv[i].sval)
free(pv[i].sval);
}
for (i = 0; i < KRB5_NUM_OF_ADDRS; i++) {
if (tmpaddrs[i])
free(tmpaddrs[i]);
}
if (tmpprinz) free(tmpprinz); /* And these too. */
if (tmppswd) free(tmppswd);
if (tmpcache) free(tmpcache);
if (tmprealm) free(tmprealm);
if (tmpinst) free(tmpinst);
return(rc); /* Return the return code */
}
#endif /* CK_KERBEROS */
#ifdef CK_LOGIN
int
#ifdef CK_ANSIC
ckxlogin(CHAR * userid, CHAR * passwd, CHAR * acct, int promptok)
#else /* CK_ANSIC */
ckxlogin(userid, passwd, acct, promptok)
CHAR * userid; CHAR * passwd; CHAR * acct; int promptok;
#endif /* CK_ANSIC */
/* ckxlogin */ {
#ifdef CK_RECALL
int sv_recall; /* For turning off command recall */
extern int on_recall; /* around Password prompting */
#endif /* CK_RECALL */
#ifdef CK_PAM
extern int guest;
#endif /* CK_PAM */
int rprompt = 0; /* Restore prompt */
#ifdef CKSYSLOG
int savlog;
#endif /* CKSYSLOG */
extern int what, srvcdmsg;
int x = 0, ok = 0, rc = 0;
CHAR * _u = NULL, * _p = NULL, * _a = NULL;
debug(F111,"ckxlogin userid",userid,promptok);
debug(F110,"ckxlogin passwd",passwd,0);
isguest = 0; /* Global "anonymous" flag */
if (!userid) userid = (CHAR *)"";
if (!passwd) passwd = (CHAR *)"";
debug(F111,"ckxlogin userid",userid,what);
#ifdef CK_RECALL
sv_recall = on_recall; /* Save and turn off command recall */
on_recall = 0;
#endif /* CK_RECALL */
#ifdef CKSYSLOG
savlog = ckxsyslog; /* Save and turn off syslogging */
#endif /* CKSYSLOG */
if ((!*userid || !*passwd) && /* Need to prompt for missing info */
promptok) {
cmsavp(psave,PROMPTL); /* Save old prompt */
debug(F110,"ckxlogin saved",psave,0);
rprompt = 1;
}
if (!*userid) {
if (!promptok)
return(0);
cmsetp("Username: "); /* Make new prompt */
concb((char)escape); /* Put console in cbreak mode */
cmini(1);
/* Flush typeahead */
#ifdef IKS_OPTION
debug(F101,
"ckxlogin TELOPT_SB(TELOPT_KERMIT).kermit.me_start",
"",
TELOPT_SB(TELOPT_KERMIT).kermit.me_start
);
#endif /* IKS_OPTION */
while (ttchk() > 0) {
x = ttinc(0);
debug(F101,"ckxlogin flush user x","",x);
#ifdef TNCODE
if (sstelnet) {
if (x == IAC) {
x = tn_doop((CHAR)(x & 0xff),ckxech,ttinc);
debug(F101,"ckxlogin user tn_doop","",x);
#ifdef IKS_OPTION
debug(F101,
"ckxlogin user TELOPT_SB(TELOPT_KERMIT).kermit.me_start",
"",
TELOPT_SB(TELOPT_KERMIT).kermit.me_start
);
#endif /* IKS_OPTION */
if (x < 0)
goto XCKXLOG;
switch (x) {
case 1: ckxech = 1; break; /* Turn on echoing */
case 2: ckxech = 0; break; /* Turn off echoing */
#ifdef IKS_OPTION
case 4: /* IKS event */
if (!TELOPT_SB(TELOPT_KERMIT).kermit.me_start)
break; /* else fall thru... */
#endif /* IKS_OPTION */
case 6: /* Logout */
goto XCKXLOG;
}
}
}
#endif /* TNCODE */
}
if (pflag) prompt(xxstring); /* Issue prompt if at top level */
cmres(); /* Reset the parser */
for (x = -1; x < 0;) { /* Prompt till they answer */
/* Get a literal line of text */
x=cmtxt("Your username, or "ftp", or "anonymous"","",&s,NULL);
if (x == -4 || x == -10) {
printf("rnLogin cancelledn");
#ifdef CKSYSLOG
ckxsyslog = savlog;
#endif /* CKSYSLOG */
doexit(GOOD_EXIT,0);
}
if (sstate) /* Did a packet come instead? */
goto XCKXLOG;
cmres(); /* Reset the parser again */
}
if ((_u = (CHAR *)malloc((int)strlen(s) + 1)) == NULL) {
printf("?Internal error: mallocn");
goto XCKXLOG;
} else {
strcpy((char *)_u,s);
userid = _u;
}
}
ok = zvuser((char *)userid); /* Verify username */
debug(F111,"ckxlogin zvuser",userid,ok);
if (!*passwd && promptok
#ifdef CK_PAM
&& guest
#endif /* CK_PAM */
) {
char prmpt[80];
#ifdef CKSYSLOG
savlog = ckxsyslog; /* Save and turn off syslogging */
ckxsyslog = 0;
#endif /* CKSYSLOG */
/* Flush typeahead again */
while (ttchk() > 0) {
x = ttinc(0);
debug(F101,"ckxlogin flush user x","",x);
#ifdef TNCODE
if (sstelnet) {
if (x == IAC) {
x = tn_doop((CHAR)(x & 0xff),ckxech,ttinc);
debug(F101,"ckxlogin pass tn_doop","",x);
#ifdef IKS_OPTION
debug(F101,
"ckxlogin pass TELOPT_SB(TELOPT_KERMIT).kermit.me_start",
"",
TELOPT_SB(TELOPT_KERMIT).kermit.me_start
);
#endif /* IKS_OPTION */
if (x < 0)
goto XCKXLOG;
switch (x) {
case 1: ckxech = 1; break; /* Turn on echoing */
case 2: ckxech = 0; break; /* Turn off echoing */
case 4: /* IKS event */
if (!TELOPT_SB(TELOPT_KERMIT).kermit.me_start)
break; /* else fall thru... */
case 6: /* Logout */
goto XCKXLOG;
}
}
}
#endif /* TNCODE */
}
if (!strcmp((char *)userid,"anonymous") ||
!strcmp((char *)userid,"ftp") )
sprintf(prmpt,"Enter e-mail address as Password: ");
else if (*userid && strlen((char *)userid) < 60) {
#ifdef NT
extern CHAR * pReferenceDomainName;
if (pReferenceDomainName)
sprintf(prmpt,"Enter %s\\%s's Password: ",
pReferenceDomainName,userid);
else
#endif /* NT */
sprintf(prmpt,"Enter %s's Password: ",userid);
} else
sprintf(prmpt,"Enter Password: ");
cmsetp(prmpt); /* Make new prompt */
concb((char)escape); /* Put console in cbreak mode */
if (strcmp((char *)userid,"anonymous") &&
strcmp((char *)userid,"ftp") ) /* and if not anonymous */
cmini(0); /* and no-echo mode */
else
cmini(1);
if (pflag) prompt(xxstring); /* Issue prompt if at top level */
cmres(); /* Reset the parser */
for (x = -1; x < 0;) { /* Prompt till they answer */
x = cmtxt("","",&s,NULL); /* Get a literal line of text */
if (x == -4 || x == -10) {
printf("rnLogin cancelledrn");
#ifdef CKSYSLOG
ckxsyslog = savlog;
#endif /* CKSYSLOG */
doexit(GOOD_EXIT,0);
}
if (sstate) /* In case of a Kermit packet */
goto XCKXLOG;
cmres(); /* Reset the parser again */
}
printf("rn"); /* Echo a CRLF */
if ((_p = (CHAR *)malloc((int)strlen(s) + 1)) == NULL) {
printf("?Internal error: mallocn");
goto XCKXLOG;
} else {
strcpy((char *)_p,s);
passwd = _p;
}
}
#ifdef CK_PAM
else {
cmres(); /* Reset the parser */
/* We restore the prompt now because the PAM engine will call */
/* readpass() which will overwrite psave. */
if (rprompt) {
cmsetp(psave); /* Restore original prompt */
debug(F110,"ckxlogin restored",psave,0);
rprompt = 0;
}
}
#endif /* CK_PAM */
#ifdef CKSYSLOG
ckxsyslog = savlog;
#endif /* CKSYSLOG */
if (ok) {
ok = zvpass((char *)passwd); /* Check password */
debug(F101,"ckxlogin zvpass","",ok);
}
if (ok > 0 && isguest) {
#ifndef NOPUSH
nopush = 1;
#endif /* NOPUSH */
srvcdmsg = 1;
}
rc = ok; /* Set the return code */
if ((char *)uidbuf != (char *)userid)
ckstrncpy(uidbuf,(char *)userid,UIDBUFLEN); /* Remember username */
XCKXLOG: /* Common exit */
#ifdef CK_RECALL
on_recall = sv_recall; /* Restore command recall */
#endif /* CK_RECALL */
#ifdef CKSYSLOG
ckxsyslog = savlog; /* In case of GOTO above */
#endif /* CKSYSLOG */
if (rprompt) {
cmsetp(psave); /* Restore original prompt */
debug(F110,"ckxlogin restored",psave,0);
}
if (_u || _p || _a) {
if (_u) free(_u);
if (_p) free(_p);
if (_a) free(_a);
}
return(rc);
}
int
ckxlogout() {
/* zvlogout(); */
doexit(GOOD_EXIT,0); /* doexit calls zvlogout */
return(0); /* not reached */
}
#endif /* CK_LOGIN */
#endif /* NOICP */