void
fg_proc_entry(struct process *pp)
{
jmp_buf_t osetexit;
int ohaderr;
Char oGettingInput;
size_t omark;
getexit(osetexit);
pintr_disabled++;
oGettingInput = GettingInput;
GettingInput = 0;
ohaderr = haderr; /* we need to ignore setting of haderr due to
* process getting stopped by a signal */
omark = cleanup_push_mark();
if (setexit() == 0) { /* come back here after pjwait */
pendjob();
(void) alarm(0); /* No autologout */
alrmcatch_disabled = 1;
if (!pstart(pp, 1)) {
pp->p_procid = 0;
stderror(ERR_BADJOB, pp->p_command, strerror(errno));
}
pjwait(pp);
}
setalarm(1); /* Autologout back on */
cleanup_pop_mark(omark);
resexit(osetexit);
haderr = ohaderr;
GettingInput = oGettingInput;
disabled_cleanup(&pintr_disabled);
}
/*
** handler for ALRM-signal
*/
void
getalarm(int sig)
{
awaittrigger=0;
if (interval.tv_sec || interval.tv_usec)
setalarm(&interval); /* restart the timer */
}
void
setalarm2(int sec, int usec)
{
struct timeval interval;
interval.tv_sec = sec;
interval.tv_usec = usec;
setalarm(&interval);
}
ulong
procalarm(ulong time)
{
Proc **l, *f;
ulong when, old, now;
now = msec();
if(up->alarm)
old = up->alarm - now;
else
old = 0;
if(time == 0) {
up->alarm = 0;
return old;
}
when = time+now;
qlock(&alarms.lk);
l = &alarms.head;
for(f = *l; f; f = f->palarm) {
if(up == f){
*l = f->palarm;
break;
}
l = &f->palarm;
}
up->palarm = 0;
if(alarms.head) {
l = &alarms.head;
for(f = *l; f; f = f->palarm) {
if(f->alarm > when) {
up->palarm = f;
*l = up;
goto done;
}
l = &f->palarm;
}
*l = up;
}
else
alarms.head = up;
done:
up->alarm = when;
setalarm();
qunlock(&alarms.lk);
return old;
}
/*
* delete timer <tp>. If <tp> is NULL, all timers are deleted
*/
void timerdel(void *handle)
{
register Timer_t *tp = (Timer_t*)handle;
if(tp)
tp->action = 0;
else
{
for(tp=tptop; tp; tp=tp->next)
tp->action = 0;
if(tpmin)
{
tpmin = 0;
setalarm((double)0);
}
signal(SIGALRM,(sh.sigflag[SIGALRM]&SH_SIGFAULT)?sh_fault:SIG_DFL);
}
}
void *sh_timeradd(unsigned long msec,int flags,void (*action)(void*),void *handle)
{
register Timer_t *tp;
double t;
Handler_t fn;
t = ((double)msec)/1000.;
if(t<=0 || !action)
return((void*)0);
if(tp=tpfree)
tpfree = tp->next;
else if(!(tp=(Timer_t*)malloc(sizeof(Timer_t))))
return((void*)0);
tp->wakeup = getnow() + t;
tp->incr = (flags?t:0);
tp->action = action;
tp->handle = handle;
time_state |= IN_ADDTIMEOUT;
tp->next = tptop;
tptop = tp;
if(!tpmin || tp->wakeup < tpmin->wakeup)
{
tpmin = tp;
fn = (Handler_t)signal(SIGALRM,sigalrm);
if((t= setalarm(t))>0 && fn && fn!=(Handler_t)sigalrm)
{
Handler_t *hp = (Handler_t*)malloc(sizeof(Handler_t));
if(hp)
{
*hp = fn;
sh_timeradd((long)(1000*t), 0, oldalrm, (void*)hp);
}
}
tp = tptop;
}
else if(tpmin && !tpmin->action)
time_state |= DEFER_SIGALRM;
time_state &= ~IN_ADDTIMEOUT;
if(time_state&DEFER_SIGALRM)
{
time_state=SIGALRM_CALL;
sigalrm(SIGALRM);
if(tp!=tptop)
tp=0;
}
return((void*)tp);
}
static void
soundalarms(Ureg *u, Timer *t)
{
ulong now;
Proc *rp;
now = msec();
qlock(&alarms.lk);
while((rp = alarms.head) && rp->alarm <= now){
if(rp->alarm != 0){
if(!canqlock(&rp->debug))
break;
if(!waserror()){
postnote(rp, 0, "alarm", NUser);
poperror();
}
qunlock(&rp->debug);
rp->alarm = 0;
}
alarms.head = rp->palarm;
}
setalarm();
qunlock(&alarms.lk);
}
void
alrmcatch(void)
{
(*alm_fun)();
setalarm(1);
}
/*ARGSUSED*/
static void
auto_lock(void)
{
#ifndef NO_CRYPT
int i;
char *srpp = NULL;
struct passwd *pw;
#undef XCRYPT
#if defined(HAVE_AUTH_H) && defined(HAVE_GETAUTHUID)
struct authorization *apw;
extern char *crypt16 (const char *, const char *);
# define XCRYPT(pw, a, b) crypt16(a, b)
if ((pw = xgetpwuid(euid)) != NULL && /* effective user passwd */
(apw = getauthuid(euid)) != NULL) /* enhanced ultrix passwd */
srpp = apw->a_password;
#elif defined(HAVE_SHADOW_H)
struct spwd *spw;
# define XCRYPT(pw, a, b) crypt(a, b)
if ((pw = xgetpwuid(euid)) != NULL) { /* effective user passwd */
errno = 0;
while ((spw = getspnam(pw->pw_name)) == NULL && errno == EINTR) {
handle_pending_signals();
errno = 0;
}
if (spw != NULL) /* shadowed passwd */
srpp = spw->sp_pwdp;
}
#else
#ifdef __CYGWIN__
# define XCRYPT(pw, a, b) cygwin_xcrypt(pw, a, b)
#else
# define XCRYPT(pw, a, b) crypt(a, b)
#endif
#if !defined(__MVS__)
if ((pw = xgetpwuid(euid)) != NULL) /* effective user passwd */
srpp = pw->pw_passwd;
#endif /* !MVS */
#endif
if (srpp == NULL) {
auto_logout();
/*NOTREACHED*/
return;
}
setalarm(0); /* Not for locking any more */
xputchar('\n');
for (i = 0; i < 5; i++) {
const char *crpp;
char *pp;
#ifdef AFS
char *afsname;
Char *safs;
if ((safs = varval(STRafsuser)) != STRNULL)
afsname = short2str(safs);
else
if ((afsname = getenv("AFSUSER")) == NULL)
afsname = pw->pw_name;
#endif
pp = xgetpass("Password:"******"\nIncorrect passwd for %s\n"), pw->pw_name);
}
#endif /* NO_CRYPT */
auto_logout();
}
/* ------------------------------------------------------------------------- */
int tx_zmodem(s_protinfo *pi, bool caller)
{
int startblk = 64; /* Initial Zmodem block size */
int minblk = 64; /* Minimal Z-protocol block size */
int maxblk = 1024;/* Maximal Z-protocol block size */
int blocklen = 0; /* Length of transmitted blocks */
int goodblk = 0; /* How many blocks we sent w/o ZRPOS'tion :) */
int txwindow = 0; /* Tranmitter window size (0 means streaming) */
int newcnt = 0; /* Count free bytes in receiver's buffer */
int rxbuflen = 0; /* Receiver's max buffer length */
int rxlastpos = 0; /* Receiver's last reported offset */
int beenhere = 0; /* How many times we've been ZRPOS'd same place */
long bytescnt = 0; /* Received bytes(current offset) */
long lastsync = 0; /* Last offset to which we got a ZRPOS */
char zconv = 0; /* Local ZMODEM file conversion request */
char zmanag = 0; /* Local ZMODEM file management request */
char ztrans = 0; /* Local ZMODEM file translation request */
char zexten = 0; /* Local ZMODEM file extended options */
char *txbuf = NULL;/* Buffer with ZMAXBLOCKLEN size */
int zrinitcnt = 0; /* Count received ZRINITs */
int rxflags1 = 0;
int rxflags2 = 0;
int txtries = 0;
int junkcnt = 0;
int initacked = 0; /* TRUE when at least one ZRQINIT was sent */
/* after first ZRINIT was received */
int rc = 0; /* Our return code */
int dtype, n;
int ftype;
char c, *p;
long unsigned crc32;
enum ztxstates txstate;
time_t deadtimer;
log("start %s send", Protocols[state.handshake->protocol]);
DEB((D_PROT, "start %s send", Protocols[state.handshake->protocol]));
/* Set time transfer started at */
if( pi->start_time == 0 )
pi->start_time = time(NULL);
txbuf = (char *)xmalloc(ZMAXBLOCKLEN+1);
zconv = ZCBIN;
maxblk = (state.handshake->protocol == PROT_ZMODEM) ? 1024 : 8192;
/* Set initial block size (default is 128b) */
if( (startblk = conf_number(cf_zmodem_start_block_size)) > 0 )
{
if( startblk%64 || startblk > maxblk || startblk < 64 )
startblk = 256;
} else
startblk = 256;
blocklen = startblk;
txwindow = conf_number(cf_zmodem_tx_window);
Z_Rxwait = ZWAITTIME;
Z_Rxtout = ZRXTIMEOUT;
txstate = ZTX_START;
timer_set(&deadtimer, ZDEADTIMER);
setalarm(Z_Rxtout);
/*
* At zmodem batches send empty netmail packet
* if no real outgoing traffic available
*/
if( !pi->send_left_size && conf_boolean(cf_zmodem_send_dummy_pkt) )
zmodem_add_empty_packet(pi);
while(1)
{
if( timer_expired(deadtimer) )
{
log("brain dead! (abort)");
gotoexit(PRC_LOCALABORTED);
}
if( txstate == ZTX_RQINIT || txstate == ZTX_FINFO
|| txstate == ZTX_EOF || txstate == ZTX_FIN )
{
#ifdef DEBUG
if( txtries ) DEB((D_PROT, "tx_zmodem: try #%d", txtries));
#endif
if( ++txtries > ZMAXTRIES )
{
log("out of tries");
gotoexit(PRC_LOCALABORTED);
}
}
switch(txstate) {
case ZTX_START:
DEB((D_PROT, "tx_zmodem: entering state ZTX_START"));
if( PUTSTR("rz\r") < 0 )
gotoexit(PRC_ERROR);
txtries = 0;
txstate = ZTX_RQINIT;
break;
case ZTX_RQINIT:
DEB((D_PROT, "tx_zmodem: entering state ZTX_RQINIT"));
stohdr(Z_Txhdr, 0L);
if( zshhdr(ZRQINIT, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
setalarm(Z_Rxtout);
txstate = ZTX_RQINITACK;
break;
case ZTX_NEXTFILE:
DEB((D_PROT, "tx_zmodem: entering state ZTX_NEXTFILE"));
if (pi->send) p_tx_fclose(pi);
txtries = 0;
txstate = p_tx_fopen(pi, NULL) ? ZTX_FIN : ZTX_FINFO;
log("nextfile next state: %d", txstate);
break;
case ZTX_FINFO:
DEB((D_PROT, "tx_zmodem: entering state ZTX_FINFO"));
zrinitcnt = 0;
strnxcpy(txbuf, pi->send->net_name, ZMAXFNAME);
p = txbuf + strlen(txbuf) + 1;
sprintf(p, "%ld %lo %lo 0 %ld %ld",
(long)pi->send->bytes_total, (long)pi->send->mod_time,
(long)pi->send->mode, (long)pi->send_left_num,
(long)pi->send_left_size);
DEB((D_PROT, "tx_zmodem: send \"%s\\000%s\"", txbuf, p));
Z_Txhdr[ZF0] = zconv; /* file conversion request */
Z_Txhdr[ZF1] = zmanag; /* file management request */
Z_Txhdr[ZF2] = ztrans; /* file transport request */
Z_Txhdr[ZF3] = zexten;
if( zsbhdr(ZFILE, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
if( zsdata(txbuf, (p - txbuf) + strlen(p), ZCRCW, 0) < 0 )
gotoexit(PRC_ERROR);
setalarm(Z_Rxtout);
txstate = ZTX_FINFOACK;
break;
case ZTX_STARTDATA:
DEB((D_PROT, "tx_zmodem: entering state ZTX_STARTDATA"));
newcnt = rxbuflen;
junkcnt = 0;
stohdr(Z_Txhdr, pi->send->bytes_sent);
if( zsbhdr(ZDATA, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
txstate = ZTX_DATA;
break;
case ZTX_DATA:
DEB((D_PROT, "tx_zmodem: entering state ZTX_DATA"));
timer_set(&deadtimer, ZDEADTIMER);
setalarm(Z_Rxtout); /* Remove annoing timeouts! */
if( (n = p_tx_readfile(txbuf, blocklen, pi)) < 0 )
{
/* error occured, remote wait for DATA */
/* so send null ZCRCE data subpacket */
if( zsdata(txbuf, 0, ZCRCE, 0) < 0 )
gotoexit(PRC_ERROR);
txstate = ZTX_NEXTFILE;
break;
}
if( pi->send->eofseen )
dtype = ZCRCE;
else if( junkcnt > 6 )
dtype = ZCRCW;
else if( bytescnt == lastsync )
dtype = ZCRCW;
else if( rxbuflen && (newcnt -= n) <= 0 )
dtype = ZCRCW;
else if( txwindow && (bytescnt - rxlastpos + n) >= txwindow )
dtype = ZCRCQ;
else
dtype = ZCRCG;
if( (rc = p_info(pi, 0)) )
gotoexit(rc);
if( zsdata(txbuf, n, dtype, pi->send->bytes_sent) < 0 )
gotoexit(PRC_ERROR);
if( ++goodblk > 5 && blocklen*2 <= maxblk )
{
goodblk = 0;
blocklen *= 2;
DEB((D_PROT, "tx_zmodem: new blocklen = %ld byte(s)", blocklen));
}
bytescnt = pi->send->bytes_sent += n;
if( dtype == ZCRCW )
{
junkcnt = 0;
setalarm(Z_Rxtout);
txstate = ZTX_CRCWACK;
break;
}
else if( dtype == ZCRCQ )
{
junkcnt = 0;
setalarm(Z_Rxtout);
txstate = ZTX_CRCQACK;
break;
}
else if( dtype == ZCRCE )
{
txtries = 0;
txstate = ZTX_EOF;
break;
}
if( CHARWAIT(0) )
{
while( (rc = GETCHAR(1)) != ZTIMER )
{
if( rc < 0 )
{
gotoexit(PRC_ERROR);
}
else if( rc == CAN || rc == ZPAD )
{
DEB((D_PROT, "tx_zmodem: got ZPAD or CAN!"));
setalarm(Z_Rxtout);
txstate = ZTX_READCHECK;
break;
}
else if( rc == XOFF || rc == (XOFF|0200) )
{
DEB((D_PROT, "tx_zmodem: got XOFF"));
if( GETCHAR(5) < 0 )
gotoexit(PRC_ERROR);
break;
}
else if( rc == XON || rc == (XON|0200) )
{
DEB((D_PROT, "tx_zmodem: got XON"));
}
else
{
junkcnt++;
DEB((D_PROT, "tx_zmodem: got JUNK = 0x%x (junkcnt = %d)",
rc, junkcnt));
}
} /* end of while( rc != ZTIMER ) */
} /* end of if( CHARWAIT(0) ) */
break;
case ZTX_EOF:
DEB((D_PROT, "tx_zmodem: entering state ZTX_EOF"));
stohdr(Z_Txhdr, pi->send->bytes_sent);
if( zsbhdr(ZEOF, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
setalarm(Z_Rxtout);
txstate = ZTX_EOFACK;
break;
case ZTX_FIN:
DEB((D_PROT, "tx_zmodem: entering state ZTX_FIN"));
stohdr(Z_Txhdr, 0L);
if( zshhdr(ZFIN, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
setalarm(Z_Rxtout);
txstate = ZTX_FINACK;
break;
default:
/* Ignore them all */
break;
} /* end of switch(txstate) */
if( txstate != ZTX_START && txstate != ZTX_RQINIT
&& txstate != ZTX_FINFO && txstate != ZTX_DATA
&& txstate != ZTX_EOF && txstate != ZTX_FIN )
{
switch( ftype = zgethdr(Z_Rxhdr) ) {
case ZCAN:
gotoexit(PRC_REMOTEABORTED);
break;
case ZHANGUP:
case ZEXIT:
gotoexit(PRC_ERROR);
break;
case ZTIMER:
log("time out");
if( txstate == ZTX_READCHECK )
zsdata(txbuf, 0, ZCRCE, 0);
switch(txstate) {
case ZTX_RQINITACK: txstate = ZTX_RQINIT; break;
case ZTX_FINFOACK: txstate = ZTX_FINFO; break;
case ZTX_READCHECK: txstate = ZTX_STARTDATA; break;
case ZTX_CRCWACK: txstate = ZTX_STARTDATA; break;
case ZTX_CRCQACK: txstate = ZTX_STARTDATA; break;
case ZTX_EOFACK: txstate = ZTX_EOF; break;
case ZTX_FINACK: txstate = ZTX_FIN; break;
default: break;
}
break;
case ZERROR:
case ZCRCERR:
/* NAK them all! */
stohdr(Z_Txhdr, 0L);
if( zshhdr(ZNAK, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
break;
case ZRQINIT:
if( txstate == ZTX_RQINITACK )
{
if( Z_Rxhdr[0] == ZCOMMAND )
break;
stohdr(Z_Txhdr, 0L);
if( zshhdr(ZNAK, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
txstate = ZTX_RQINIT;
}
else if( txstate == ZTX_FINFOACK )
{
/* remote is sender - abort */
log("zmodem: remote is sender");
gotoexit(PRC_LOCALABORTED);
}
break;
case ZRINIT:
if( txstate == ZTX_RQINITACK )
{
if( initacked == 0 )
{
/* Be sure ack first ZRINIT */
stohdr(Z_Txhdr, 0L);
if( zshhdr(ZRQINIT, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
initacked = 1;
}
/* Get receiver's options */
rxflags1 = (0377 & Z_Rxhdr[ZF0]);
rxflags2 = (0377 & Z_Rxhdr[ZF1]);
Z_Txfcs32 = (rxflags1 & CANFC32);
Z_Ctlesc |= (rxflags1 & TESCCTL);
rxbuflen = (0377 & Z_Rxhdr[ZP0]);
rxbuflen += ((0377 & Z_Rxhdr[ZP1])<<8);
/* No ZCRCQ if remote doesn't indicate */
/* FDX ability */
if( !(rxflags1 & CANFDX) )
txwindow = 0;
DEB((D_PROT, "tx_zmodem: Z_Txfcs32 = %d Z_Ctlesc = %d",
Z_Txfcs32, Z_Ctlesc));
DEB((D_PROT, "tx_zmodem: rxbuflen = %d blocklen = %d",
rxbuflen, blocklen));
DEB((D_PROT, "tx_zmodem: txwindow = %u",
txwindow));
txstate = ZTX_NEXTFILE;
}
else if( txstate == ZTX_FINFOACK )
{
/* Possible they didn't see */
/* our file information */
if( ++zrinitcnt > 2 )
txstate = ZTX_FINFO;
}
else if( txstate == ZTX_READCHECK
|| txstate == ZTX_CRCQACK
|| txstate == ZTX_CRCWACK )
{
if( txstate == ZTX_READCHECK
|| txstate == ZTX_CRCQACK )
zsdata(txbuf, 0, ZCRCE, 0);
/* Assume file normaly sent ? */
log("assume file normaly sent");
pi->send->status = FSTAT_SUCCESS;
txstate = ZTX_NEXTFILE;
}
else if( txstate == ZTX_EOFACK )
{
/* ok, send next */
pi->send->status = FSTAT_SUCCESS;
txstate = ZTX_NEXTFILE;
}
else if( txstate == ZTX_FINACK )
{
/* Possible we should ignore */
/* first ZRINIT. Because they */
/* didn't see our first ZFIN */
/* But I'm soo lazy .. :)) */
txstate = ZTX_FIN;
}
break;
case ZACK:
if( txstate == ZTX_CRCWACK )
{
rxlastpos = Z_Rxpos;
if( pi->send->bytes_sent == Z_Rxpos )
txstate = ZTX_STARTDATA;
}
else if( txstate == ZTX_READCHECK
|| txstate == ZTX_CRCQACK )
{
rxlastpos = Z_Rxpos;
txstate = ZTX_DATA;
}
break;
case ZSKIP:
if( txstate == ZTX_FINFOACK
|| txstate == ZTX_READCHECK
|| txstate == ZTX_CRCQACK
|| txstate == ZTX_CRCWACK
|| txstate == ZTX_EOFACK )
{
if( txstate == ZTX_READCHECK
|| txstate == ZTX_CRCQACK )
zsdata(txbuf, 0, ZCRCE, 0);
if( txstate == ZTX_READCHECK )
CLEAROUT();
pi->send->status = FSTAT_SKIPPED;
log("remote side skipped file");
txstate = ZTX_NEXTFILE;
}
break;
case ZFIN:
/* BUG!BUG!BUG!BUG!BUG!BUG!BUG!BUG!BUG! */
/* BUG!BUG!BUG!BUG!BUG!BUG!BUG!BUG!BUG! */
log(" BUG!BUG!BUG!BUG!BUG!BUG!BUG!BUG!BUG! ");
if( txstate == ZTX_FINACK )
{
if( PUTSTR("OO") == 0 )
FLUSHOUT();
gotoexit(PRC_NOERROR);
}
break;
case ZRPOS:
if( txstate == ZTX_FINFOACK
|| txstate == ZTX_READCHECK
|| txstate == ZTX_CRCQACK
|| txstate == ZTX_CRCWACK
|| txstate == ZTX_EOFACK )
{
rxlastpos = Z_Rxpos;
/* Clear modem buffers */
/* if( txstate != FINFOACK ) SENDBREAK(); */
if( txstate == ZTX_READCHECK ) CLEAROUT();
if( txstate == ZTX_READCHECK
|| txstate == ZTX_CRCQACK )
{
if( zsdata(txbuf, 0, ZCRCE, 0) < 0 )
gotoexit(PRC_ERROR);
}
/* Reset EOF flag! */
pi->send->eofseen = FALSE;
/* Check pos */
if( (Z_Rxpos || txstate != ZTX_FINFOACK)
&& p_tx_rewind(pi, Z_Rxpos) )
{
logerr("can't send file from requested position");
/* Open next file for send */
txstate = ZTX_NEXTFILE;
break;
}
if( txstate == ZTX_FINFOACK )
{
if( Z_Rxpos )
{
log("resyncing at offset %d", Z_Rxpos);
pi->send->bytes_skipped = Z_Rxpos;
}
}
else if( txstate == ZTX_READCHECK
|| txstate == ZTX_CRCWACK
|| txstate == ZTX_CRCQACK )
{
goodblk = 0;
if( lastsync >= Z_Rxpos && ++beenhere > 4 )
if( blocklen > minblk )
{
blocklen /= 2;
DEB((D_PROT, "tx_zmodem: falldown to %ld BlockLen", blocklen));
}
}
lastsync = bytescnt = pi->send->bytes_sent = Z_Rxpos;
if( txstate == ZTX_FINFOACK )
--lastsync;
txstate = ZTX_STARTDATA;
}
break;
case ZNAK:
switch(txstate) {
case ZTX_RQINITACK: txstate = ZTX_RQINIT; break;
case ZTX_FINFOACK: txstate = ZTX_FINFO; break;
case ZTX_EOFACK: txstate = ZTX_EOF; break;
case ZTX_FINACK: txstate = ZTX_FIN; break;
default: break;
}
break;
case ZCRC:
if( txstate == ZTX_FINFOACK )
{
log(" Send file's CRC-32 ");
crc32 = 0xFFFFFFFFL;
while( ((c = getc(pi->send->fp)) != EOF) && --Z_Rxpos )
crc32 = updcrc32(c, crc32);
crc32 = ~crc32;
clearerr(pi->send->fp); /* Clear EOF */
fseek(pi->send->fp, 0L, 0);
stohdr(Z_Txhdr, crc32);
if( zsbhdr(ZCRC, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
}
break;
case ZCHALLENGE:
if( txstate == ZTX_RQINITACK )
{
/* Echo receiver's challenge number */
stohdr(Z_Txhdr, Z_Rxpos);
if( zshhdr(ZACK, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
txstate = ZTX_RQINIT;
}
break;
case ZCOMMAND:
if( txstate == ZTX_RQINITACK )
{
txstate = ZTX_RQINIT;
}
break;
case ZABORT:
log("remote requested for session abort");
stohdr(Z_Txhdr, 0L);
if( zshhdr(ZFIN, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
gotoexit(PRC_REMOTEABORTED);
break;
case ZFERR:
if( txstate == ZTX_FINFOACK
|| txstate == ZTX_READCHECK
|| txstate == ZTX_CRCWACK
|| txstate == ZTX_CRCQACK
|| txstate == ZTX_EOFACK )
{
if( txstate == ZTX_READCHECK
|| txstate == ZTX_CRCQACK )
{
if( zsdata(txbuf, 0, ZCRCE, 0) < 0 )
gotoexit(PRC_ERROR);
}
pi->send->status = FSTAT_REFUSED;
log("remote side refused file");
txstate = ZTX_NEXTFILE;
}
break;
default:
log("got unexpected frame %d", ftype);
break;
} /* end of switch(hdr) */
} /* end of if */
} /* end of while */
exit:
DEB((D_PROT, "tx_zmodem: SEND exit = %d", rc));
setalarm(0);
if (pi->send) p_tx_fclose(pi);
if( txbuf ) {
free(txbuf);
txbuf = NULL;
}
return(rc);
}
static int parse_options(int argc, char *argv[])
{
int c;
int opt_index = -1;
gn_error rc;
/* Every option should be in this array. */
static struct option long_options[] = {
/* FIXME: these comments are nice, but they would be more useful as docs for the user */
/* Display usage. */
{ "help", optional_argument, NULL, OPT_HELP },
/* Display version and build information. */
{ "version", no_argument, NULL, OPT_VERSION },
/* Monitor mode */
{ "monitor", optional_argument, NULL, OPT_MONITOR },
/* Alternate config file location */
{ "config", required_argument, NULL, OPT_CONFIGFILE },
/* Alternate phone section from the config */
{ "phone", required_argument, NULL, OPT_CONFIGMODEL },
/* Get Security Code */
{ "getsecuritycode", no_argument, NULL, OPT_GETSECURITYCODE },
/* Enter Security Code mode */
{ "entersecuritycode", required_argument, NULL, OPT_ENTERSECURITYCODE },
/* Get Security Code status */
{ "getsecuritycodestatus", no_argument, NULL, OPT_GETSECURITYCODESTATUS },
/* Change Security Code */
{ "changesecuritycode", required_argument, NULL, OPT_CHANGESECURITYCODE },
/* Set date and time */
{ "setdatetime", optional_argument, NULL, OPT_SETDATETIME },
/* Get date and time mode */
{ "getdatetime", no_argument, NULL, OPT_GETDATETIME },
/* Set alarm */
{ "setalarm", optional_argument, NULL, OPT_SETALARM },
/* Get alarm */
{ "getalarm", no_argument, NULL, OPT_GETALARM },
/* Voice call mode */
{ "dialvoice", required_argument, NULL, OPT_DIALVOICE },
/* Answer the incoming call */
{ "answercall", required_argument, NULL, OPT_ANSWERCALL },
/* Hangup call */
{ "hangup", required_argument, NULL, OPT_HANGUP },
/* Get ToDo note mode */
{ "gettodo", required_argument, NULL, OPT_GETTODO },
/* Write ToDo note mode */
{ "writetodo", required_argument, NULL, OPT_WRITETODO },
/* Delete all ToDo notes mode */
{ "deletealltodos", no_argument, NULL, OPT_DELETEALLTODOS },
/* Get calendar note mode */
{ "getcalendarnote", required_argument, NULL, OPT_GETCALENDARNOTE },
/* Write calendar note mode */
{ "writecalendarnote", required_argument, NULL, OPT_WRITECALENDARNOTE },
/* Delete calendar note mode */
{ "deletecalendarnote", required_argument, NULL, OPT_DELCALENDARNOTE },
/* Get display status mode */
{ "getdisplaystatus", no_argument, NULL, OPT_GETDISPLAYSTATUS },
/* Get memory mode */
{ "getphonebook", required_argument, NULL, OPT_GETPHONEBOOK },
/* Write phonebook (memory) mode */
{ "writephonebook", optional_argument, NULL, OPT_WRITEPHONEBOOK },
/* Delete phonebook entry from memory mode */
{ "deletephonebook", required_argument, NULL, OPT_DELETEPHONEBOOK },
/* Get speed dial mode */
{ "getspeeddial", required_argument, NULL, OPT_GETSPEEDDIAL },
/* Set speed dial mode */
{ "setspeeddial", required_argument, NULL, OPT_SETSPEEDDIAL },
/* Create SMS folder mode */
{ "createsmsfolder", required_argument, NULL, OPT_CREATESMSFOLDER },
/* Delete SMS folder mode */
{ "deletesmsfolder", required_argument, NULL, OPT_DELETESMSFOLDER },
/* Show SMS folder names and its attributes */
{ "showsmsfolderstatus",no_argument, NULL, OPT_SHOWSMSFOLDERSTATUS },
/* Get SMS message mode */
{ "getsms", required_argument, NULL, OPT_GETSMS },
/* Delete SMS message mode */
{ "deletesms", required_argument, NULL, OPT_DELETESMS },
/* Send SMS message mode */
{ "sendsms", required_argument, NULL, OPT_SENDSMS },
/* Ssve SMS message mode */
{ "savesms", optional_argument, NULL, OPT_SAVESMS },
/* Send logo as SMS message mode */
{ "sendlogo", required_argument, NULL, OPT_SENDLOGO },
/* Send ringtone as SMS message */
{ "sendringtone", required_argument, NULL, OPT_SENDRINGTONE },
/* Get ringtone */
{ "getringtone", required_argument, NULL, OPT_GETRINGTONE },
/* Set ringtone */
{ "setringtone", required_argument, NULL, OPT_SETRINGTONE },
/* Play ringtone */
{ "playringtone", required_argument, NULL, OPT_PLAYRINGTONE },
/* Convert ringtone */
{ "ringtoneconvert", required_argument, NULL, OPT_RINGTONECONVERT },
/* Get list of the ringtones */
{ "getringtonelist", no_argument, NULL, OPT_GETRINGTONELIST },
/* Delete ringtones */
{ "deleteringtone", required_argument, NULL, OPT_DELETERINGTONE },
/* Get SMS center number mode */
{ "getsmsc", optional_argument, NULL, OPT_GETSMSC },
/* Set SMS center number mode */
{ "setsmsc", no_argument, NULL, OPT_SETSMSC },
/* For development purposes: run in passive monitoring mode */
{ "pmon", no_argument, NULL, OPT_PMON },
/* NetMonitor mode */
{ "netmonitor", required_argument, NULL, OPT_NETMONITOR },
/* Identify */
{ "identify", no_argument, NULL, OPT_IDENTIFY },
/* Send DTMF sequence */
{ "senddtmf", required_argument, NULL, OPT_SENDDTMF },
/* Resets the phone */
{ "reset", required_argument, NULL, OPT_RESET },
/* Set logo */
{ "setlogo", required_argument, NULL, OPT_SETLOGO },
/* Get logo */
{ "getlogo", required_argument, NULL, OPT_GETLOGO },
/* View logo */
{ "viewlogo", required_argument, NULL, OPT_VIEWLOGO },
/* Show profile */
{ "getprofile", optional_argument, NULL, OPT_GETPROFILE },
/* Set profile */
{ "setprofile", no_argument, NULL, OPT_SETPROFILE },
/* Get the active profile */
{ "getactiveprofile", no_argument, NULL, OPT_GETACTIVEPROFILE },
/* Set the active profile */
{ "setactiveprofile", required_argument, NULL, OPT_SETACTIVEPROFILE },
/* Show texts from phone's display */
{ "displayoutput", no_argument, NULL, OPT_DISPLAYOUTPUT },
/* Simulate pressing the keys */
{ "keysequence", no_argument, NULL, OPT_KEYPRESS },
/* Simulate pressing the keys */
{ "enterchar", no_argument, NULL, OPT_ENTERCHAR },
/* Divert calls */
{ "divert", no_argument, NULL, OPT_DIVERT },
/* SMS reader */
{ "smsreader", no_argument, NULL, OPT_SMSREADER },
/* For development purposes: insert you function calls here */
{ "foogle", no_argument, NULL, OPT_FOOGLE },
/* Get WAP bookmark */
{ "getwapbookmark", required_argument, NULL, OPT_GETWAPBOOKMARK },
/* Write WAP bookmark */
{ "writewapbookmark", required_argument, NULL, OPT_WRITEWAPBOOKMARK },
/* Delete WAP bookmark */
{ "deletewapbookmark", required_argument, NULL, OPT_DELETEWAPBOOKMARK },
/* Get WAP setting */
{ "getwapsetting", required_argument, NULL, OPT_GETWAPSETTING },
/* Write WAP setting */
{ "writewapsetting", no_argument, NULL, OPT_WRITEWAPSETTING },
/* Activate WAP setting */
{ "activatewapsetting", required_argument, NULL, OPT_ACTIVATEWAPSETTING },
/* List GSM networks */
{ "listnetworks", no_argument, NULL, OPT_LISTNETWORKS },
/* Get network info */
{ "getnetworkinfo", no_argument, NULL, OPT_GETNETWORKINFO },
/* Get (sim)lock info */
{ "getlocksinfo", no_argument, NULL, OPT_GETLOCKSINFO },
/* Get file list */
{ "getfilelist", required_argument, NULL, OPT_GETFILELIST },
/* Get file details by id */
{ "getfiledetailsbyid", optional_argument, NULL, OPT_GETFILEDETAILSBYID },
/* Get file id */
{ "getfileid", required_argument, NULL, OPT_GETFILEID },
/* Get file */
{ "getfile", required_argument, NULL, OPT_GETFILE },
/* Get file by id */
{ "getfilebyid", required_argument, NULL, OPT_GETFILEBYID },
/* Get all files */
{ "getallfiles", required_argument, NULL, OPT_GETALLFILES },
/* Put a file */
{ "putfile", required_argument, NULL, OPT_PUTFILE },
/* Delete a file */
{ "deletefile", required_argument, NULL, OPT_DELETEFILE },
/* Delete a file by id */
{ "deletefilebyid", required_argument, NULL, OPT_DELETEFILEBYID },
/* Shell like interface */
{ "shell", no_argument, NULL, OPT_SHELL },
/* Get MMS message mode */
{ "getmms", required_argument, NULL, OPT_GETMMS },
/* Delete MMS message mode */
{ "deletemms", required_argument, NULL, OPT_DELETEMMS },
/* Check if the phone responds */
{ "ping", no_argument, NULL, OPT_PING },
{ 0, 0, 0, 0 },
};
/* Every command which requires arguments should have an appropriate entry
in this array. */
static struct gnokii_arg_len gals[] = {
{ OPT_HELP, 1, 100, 0 },
{ OPT_CONFIGFILE, 1, 100, 0 },
{ OPT_CONFIGMODEL, 1, 100, 0 },
{ OPT_ENTERSECURITYCODE, 1, 100, 0 },
{ OPT_CHANGESECURITYCODE,1, 1, 0 },
{ OPT_SETDATETIME, 0, 5, 0 },
{ OPT_SETALARM, 0, 2, 0 },
{ OPT_DIALVOICE, 1, 1, 0 },
{ OPT_ANSWERCALL, 1, 1, 0 },
{ OPT_HANGUP, 1, 1, 0 },
{ OPT_GETTODO, 1, 3, 0 },
{ OPT_WRITETODO, 2, 3, 0 },
{ OPT_GETCALENDARNOTE, 1, 3, 0 },
{ OPT_WRITECALENDARNOTE, 2, 3, 0 },
{ OPT_DELCALENDARNOTE, 1, 2, 0 },
{ OPT_GETPHONEBOOK, 2, 4, 0 },
{ OPT_WRITEPHONEBOOK, 0, 10, 0 },
{ OPT_DELETEPHONEBOOK, 2, 3, 0 },
{ OPT_GETSPEEDDIAL, 1, 1, 0 },
{ OPT_SETSPEEDDIAL, 3, 3, 0 },
{ OPT_CREATESMSFOLDER, 1, 1, 0 },
{ OPT_DELETESMSFOLDER, 1, 1, 0 },
{ OPT_GETSMS, 2, 6, 0 },
{ OPT_DELETESMS, 2, 3, 0 },
{ OPT_SENDSMS, 1, 10, 0 },
{ OPT_SAVESMS, 0, 12, 0 },
{ OPT_SENDLOGO, 3, 4, GAL_XOR },
{ OPT_SENDRINGTONE, 2, 2, 0 },
{ OPT_GETSMSC, 0, 3, 0 },
{ OPT_GETWELCOMENOTE, 1, 1, 0 },
{ OPT_SETWELCOMENOTE, 1, 1, 0 },
{ OPT_NETMONITOR, 1, 1, 0 },
{ OPT_SENDDTMF, 1, 1, 0 },
{ OPT_SETLOGO, 1, 4, 0 },
{ OPT_GETLOGO, 1, 4, 0 },
{ OPT_VIEWLOGO, 1, 1, 0 },
{ OPT_GETRINGTONE, 1, 3, 0 },
{ OPT_SETRINGTONE, 1, 5, 0 },
{ OPT_PLAYRINGTONE, 1, 3, 0 },
{ OPT_RINGTONECONVERT, 2, 2, 0 },
{ OPT_DELETERINGTONE, 1, 2, 0 },
{ OPT_RESET, 0, 1, 0 },
{ OPT_GETPROFILE, 0, 3, 0 },
{ OPT_SETACTIVEPROFILE, 1, 1, 0 },
{ OPT_DIVERT, 6, 10, 0 },
{ OPT_GETWAPBOOKMARK, 1, 1, 0 },
{ OPT_WRITEWAPBOOKMARK, 2, 2, 0 },
{ OPT_DELETEWAPBOOKMARK, 1, 1, 0 },
{ OPT_GETWAPSETTING, 1, 2, 0 },
{ OPT_ACTIVATEWAPSETTING,1, 1, 0 },
{ OPT_MONITOR, 0, 1, 0 },
{ OPT_GETFILELIST, 1, 1, 0 },
{ OPT_GETFILEDETAILSBYID,0, 1, 0 },
{ OPT_GETFILEID, 1, 1, 0 },
{ OPT_GETFILE, 1, 2, 0 },
{ OPT_GETFILEBYID, 1, 2, 0 },
{ OPT_GETALLFILES, 1, 1, 0 },
{ OPT_PUTFILE, 2, 2, 0 },
{ OPT_DELETEFILE, 1, 1, 0 },
{ OPT_DELETEFILEBYID, 1, 1, 0 },
{ OPT_SHELL, 0, 0, 0 },
{ OPT_GETMMS, 2, 6, 0 },
{ OPT_DELETEMMS, 2, 3, 0 },
{ OPT_FOOGLE, 0, 0, 0 },
{ OPT_PING, 0, 0, 0 },
{ 0, 0, 0, 0 },
};
/* Handle command line arguments.
* -c equals to --config
* -p equals to --phone
*/
c = getopt_long(argc, argv, "c:p:", long_options, &opt_index);
switch (c) {
/* No argument given - we should display usage. */
case -1:
return usage(stderr, -1, NULL);
/* First, error conditions */
case '?':
case ':':
/* --shell command does not set argv[0] */
if (argv[0])
fprintf(stderr, _("Use '%s --help' for usage information.\n"), argv[0]);
else
fprintf(stderr, _("Use '--help' for usage information.\n"));
return 1;
/* Then, options with no arguments */
case OPT_VERSION:
version();
return 0;
/* That's a bit ugly... */
case 'c':
c = OPT_CONFIGFILE;
opt_index = 0;
break;
case 'p':
c = OPT_CONFIGMODEL;
opt_index = 1;
break;
}
/* We have to build an array of the arguments which will be passed to the
functions. Please note that every text after the --command will be
passed as arguments. A syntax like gnokii --cmd1 args --cmd2 args will
not work as expected; instead args --cmd2 args is passed as a
parameter. */
if (checkargs(c, gals, argc, long_options[opt_index].has_arg)) {
return usage(stderr, -1, NULL);
}
/* Other options that do not need initialization */
switch (c) {
case OPT_CONFIGFILE:
if (configfile)
return usage(stderr, -1, NULL);
configfile = optarg;
return parse_options(argc, argv);
case OPT_CONFIGMODEL:
if (configmodel)
return usage(stderr, -1, NULL);
configmodel = optarg;
return parse_options(argc, argv);
case OPT_HELP:
return usage(stdout, argc, argv);
case OPT_VIEWLOGO:
return viewlogo(optarg);
case OPT_LISTNETWORKS:
list_gsm_networks();
return GN_ERR_NONE;
case OPT_RINGTONECONVERT:
return ringtoneconvert(argc, argv);
}
/* Initialise the code for the GSM interface. */
if (c != OPT_FOOGLE && state == NULL && businit())
return -1;
switch (c) {
/* Monitoring options */
case OPT_MONITOR:
rc = monitormode(argc, argv, data, state);
break;
case OPT_GETDISPLAYSTATUS:
rc = getdisplaystatus(data, state);
break;
case OPT_DISPLAYOUTPUT:
rc = displayoutput(data, state);
break;
case OPT_NETMONITOR:
rc = netmonitor(optarg, data, state);
break;
/* SMS options */
case OPT_SENDSMS:
rc = sendsms(argc, argv, data, state);
break;
case OPT_SAVESMS:
rc = savesms(argc, argv, data, state);
break;
case OPT_GETSMS:
rc = getsms(argc, argv, data, state);
break;
case OPT_DELETESMS:
rc = deletesms(argc, argv, data, state);
break;
case OPT_GETSMSC:
rc = getsmsc(argc, argv, data, state);
break;
case OPT_SETSMSC:
rc = setsmsc(data, state);
break;
case OPT_CREATESMSFOLDER:
rc = createsmsfolder(optarg, data, state);
break;
case OPT_DELETESMSFOLDER:
rc = deletesmsfolder(optarg, data, state);
break;
case OPT_SHOWSMSFOLDERSTATUS:
rc = showsmsfolderstatus(data, state);
break;
case OPT_SMSREADER:
rc = smsreader(data, state);
break;
/* Phonebook options */
case OPT_GETPHONEBOOK:
rc = getphonebook(argc, argv, data, state);
break;
case OPT_WRITEPHONEBOOK:
rc = writephonebook(argc, argv, data, state);
break;
case OPT_DELETEPHONEBOOK:
rc = deletephonebook(argc, argv, data, state);
break;
/* Calendar options */
case OPT_GETCALENDARNOTE:
rc = getcalendarnote(argc, argv, data, state);
break;
case OPT_WRITECALENDARNOTE:
rc = writecalendarnote(argc, argv, data, state);
break;
case OPT_DELCALENDARNOTE:
rc = deletecalendarnote(argc, argv, data, state);
break;
/* ToDo options */
case OPT_GETTODO:
rc = gettodo(argc, argv, data, state);
break;
case OPT_WRITETODO:
rc = writetodo(argc, argv, data, state);
break;
case OPT_DELETEALLTODOS:
rc = deletealltodos(data, state);
break;
/* Dialling and call handling options */
case OPT_GETSPEEDDIAL:
rc = getspeeddial(optarg, data, state);
break;
case OPT_SETSPEEDDIAL:
rc = setspeeddial(argv, data, state);
break;
case OPT_DIALVOICE:
rc = dialvoice(optarg, data, state);
break;
case OPT_SENDDTMF:
rc = senddtmf(optarg, data, state);
break;
case OPT_ANSWERCALL:
rc = answercall(optarg, data, state);
break;
case OPT_HANGUP:
rc = hangup(optarg, data, state);
break;
case OPT_DIVERT:
rc = divert(argc, argv, data, state);
break;
/* Profile options */
case OPT_GETPROFILE:
rc = getprofile(argc, argv, data, state);
break;
case OPT_SETPROFILE:
rc = setprofile(data, state);
break;
case OPT_GETACTIVEPROFILE:
rc = getactiveprofile(data, state);
break;
case OPT_SETACTIVEPROFILE:
rc = setactiveprofile(argc, argv, data, state);
break;
/* Phone settings options */
case OPT_RESET:
rc = reset(optarg, data, state);
break;
case OPT_GETDATETIME:
rc = getdatetime(data, state);
break;
case OPT_SETDATETIME:
rc = setdatetime(argc, argv, data, state);
break;
case OPT_GETALARM:
rc = getalarm(data, state);
break;
case OPT_SETALARM:
rc = setalarm(argc, argv, data, state);
break;
/* WAP options */
case OPT_GETWAPBOOKMARK:
rc = getwapbookmark(optarg, data, state);
break;
case OPT_WRITEWAPBOOKMARK:
rc = writewapbookmark(argc, argv, data, state);
break;
case OPT_DELETEWAPBOOKMARK:
rc = deletewapbookmark(optarg, data, state);
break;
case OPT_GETWAPSETTING:
rc = getwapsetting(argc, argv, data, state);
break;
case OPT_WRITEWAPSETTING:
rc = writewapsetting(data, state);
break;
case OPT_ACTIVATEWAPSETTING:
rc = activatewapsetting(optarg, data, state);
break;
/* Logo options */
case OPT_SENDLOGO:
rc = sendlogo(argc, argv, data, state);
break;
case OPT_SETLOGO:
rc = setlogo(argc, argv, data, state);
break;
case OPT_GETLOGO:
rc = getlogo(argc, argv, data, state);
break;
/* Ringtone options */
case OPT_SENDRINGTONE:
rc = sendringtone(argc, argv, data, state);
break;
case OPT_GETRINGTONE:
rc = getringtone(argc, argv, data, state);
break;
case OPT_SETRINGTONE:
rc = setringtone(argc, argv, data, state);
break;
case OPT_PLAYRINGTONE:
rc = playringtone(argc, argv, data, state);
break;
case OPT_GETRINGTONELIST:
rc = getringtonelist(data, state);
break;
case OPT_DELETERINGTONE:
rc = deleteringtone(argc, argv, data, state);
break;
/* Security options */
case OPT_IDENTIFY:
rc = identify(state);
break;
case OPT_GETLOCKSINFO:
rc = getlocksinfo(data, state);
break;
case OPT_GETSECURITYCODE:
rc = getsecuritycode(data, state);
break;
case OPT_ENTERSECURITYCODE:
rc = entersecuritycode(optarg, data, state);
if (rc == GN_ERR_NONE && optind < argc)
return parse_options(argc, argv);
break;
case OPT_GETSECURITYCODESTATUS:
rc = getsecuritycodestatus(data, state);
break;
case OPT_CHANGESECURITYCODE:
rc = changesecuritycode(optarg, data, state);
break;
/* File options */
case OPT_GETFILELIST:
rc = getfilelist(optarg, data, state);
break;
case OPT_GETFILEDETAILSBYID:
rc = getfiledetailsbyid(argc, argv, data, state);
break;
case OPT_GETFILEID:
rc = getfileid(optarg, data, state);
break;
case OPT_GETFILE:
rc = getfile(argc, argv, data, state);
break;
case OPT_GETFILEBYID:
rc = getfilebyid(argc, argv, data, state);
break;
case OPT_GETALLFILES:
rc = getallfiles(optarg, data, state);
break;
case OPT_PUTFILE:
rc = putfile(argc, argv, data, state);
break;
case OPT_DELETEFILE:
rc = deletefile(optarg, data, state);
break;
case OPT_DELETEFILEBYID:
rc = deletefilebyid(optarg, data, state);
break;
/* Misc options */
case OPT_PMON:
rc = pmon(data, state);
break;
case OPT_KEYPRESS:
rc = presskeysequence(data, state);
break;
case OPT_ENTERCHAR:
rc = enterchar(data, state);
break;
case OPT_GETNETWORKINFO:
rc = getnetworkinfo(data, state);
break;
case OPT_SHELL:
rc = shell(data, state);
break;
case OPT_PING:
rc = ping(data, state);
break;
#ifndef WIN32
case OPT_FOOGLE:
rc = foogle(argc, argv);
break;
#endif
/* MMS options */
case OPT_GETMMS:
rc = getmms(argc, argv, data, state);
break;
case OPT_DELETEMMS:
rc = deletemms(argc, argv, data, state);
break;
default:
rc = GN_ERR_FAILED;
fprintf(stderr, _("Unknown option: %d\n"), c);
break;
}
return rc;
}
/* signal handler for alarm call */
static void sigalrm(int sig)
{
register Timer_t *tp, *tplast, *tpold, *tpnext;
double now;
static double left;
NOT_USED(sig);
left = 0;
if(time_state&SIGALRM_CALL)
time_state &= ~SIGALRM_CALL;
else if(alarm(0))
sh_fault(SIGALRM|SH_TRAP);
if(time_state)
{
if(time_state&IN_ADDTIMEOUT)
time_state |= DEFER_SIGALRM;
errno = EINTR;
return;
}
time_state |= IN_SIGALRM;
sigrelease(SIGALRM);
while(1)
{
now = getnow();
tpold = tpmin = 0;
for(tplast=0,tp=tptop; tp; tp=tpnext)
{
tpnext = tp->next;
if(tp->action)
{
if(tp->wakeup <=now)
{
if(!tpold || tpold->wakeup>tp->wakeup)
tpold = tp;
}
else
{
if(!tpmin || tpmin->wakeup>tp->wakeup)
tpmin=tp;
}
tplast = tp;
}
else
{
if(tplast)
tplast->next = tp->next;
else
tptop = tp->next;
tp->next = tpfree;
tpfree = tp;
}
}
if((tp=tpold) && tp->incr)
{
while((tp->wakeup += tp->incr) <= now);
if(!tpmin || tpmin->wakeup>tp->wakeup)
tpmin=tp;
}
if(tpmin && (left==0 || (tp && tpmin->wakeup < (now+left))))
{
if(left==0)
signal(SIGALRM,sigalrm);
left = setalarm(tpmin->wakeup-now);
if(left && (now+left) < tpmin->wakeup)
setalarm(left);
else
left=tpmin->wakeup-now;
}
if(tp)
{
void (*action)(void*);
action = tp->action;
if(!tp->incr)
tp->action = 0;
errno = EINTR;
time_state &= ~IN_SIGALRM;
(*action)(tp->handle);
time_state |= IN_SIGALRM;
}
else
break;
}
if(!tpmin)
signal(SIGALRM,(sh.sigflag[SIGALRM]&SH_SIGFAULT)?sh_fault:SIG_DFL);
time_state &= ~IN_SIGALRM;
errno = EINTR;
}
int php3_init_request_info(void *conf)
{
static int exit_requested = 0;
int i, len;
TLS_VARS;
req = NULL;
setalarm(idle_timeout);
while (checkinput(server->infd) && (req = readrequest(server))) {
alarm(0);
if (req->reqtype == FHTTPD_REQUEST) {
if (headermade)
php3_fhttpd_free_header();
response = createresponse(1024, req->id, req->fd, req->ver_major > 0);
if (response) {
if (req->script_name && req->script_name_resolved) {
len = strlen(req->script_name);
strncpy(script_name_resolved_buffer, req->script_name_resolved, 2047);
script_name_resolved_buffer[2047] = 0;
GLOBAL(request_info).path_info = NULL; /* Not supported */
GLOBAL(request_info).path_translated = script_name_resolved_buffer;
GLOBAL(request_info).query_string = req->query_string;
GLOBAL(request_info).current_user = NULL;
GLOBAL(request_info).current_user_length = 0;
GLOBAL(request_info).request_method = method_names[req->method];
GLOBAL(request_info).script_name = req->script_name;
GLOBAL(request_info).content_length = req->databuffsize;
GLOBAL(request_info).content_type = req->content_type;
GLOBAL(request_info).cookies = NULL;
for (i = 0; i < req->nlines; i++) {
if (req->lines[i].paramc > 1) {
if (req->lines[i].params[0]) {
if (!strcasecmp(req->lines[i].params[0], "HTTP_COOKIE")) {
if (req->lines[i].params[1]) {
GLOBAL(request_info).cookies = req->lines[i].params[1];
}
}
}
}
}
/* doc_root configuration variable is currently ignored,
as it is with every other access method currently also. */
/* We always need to emalloc() filename, since it gets placed into
the include file hash table, and gets freed with that table.
Notice that this means that we don't need to efree() it in
php3_destroy_request_info()! */
if (GLOBAL(request_info).path_translated)
GLOBAL(request_info).filename = estrdup(GLOBAL(request_info).path_translated);
else
GLOBAL(request_info).filename = NULL;
return SUCCESS;
} else {
deleterequest(req);
req = NULL;
setalarm(idle_timeout);
}
} else {
deleterequest(req);
req = NULL;
setalarm(idle_timeout);
}
} else {
if (req->reqtype == FHTTPD_EXITOK) {
exit_status = 1;
deleterequest(req);
req = NULL;
setalarm(idle_timeout);
return FAILURE;
}
deleterequest(req);
req = NULL;
setalarm(idle_timeout);
}
}
if (global_alarmflag) {
if (!exit_requested) {
requestexit(server, 1);
exit_requested = 1;
}
} else {
exit_status = 1;
}
return FAILURE;
}
/*
** The engine() drives the main-loop of the program
*/
void
engine(void)
{
int i, j;
struct sigaction sigact;
double timed, delta;
void getusr1(int), getusr2(int);
/*
** reserve space for system-level statistics
*/
static struct sstat *cursstat; /* current */
static struct sstat *presstat; /* previous */
static struct sstat *devsstat; /* deviation */
static struct sstat *hlpsstat;
/*
** reserve space for task-level statistics
*/
static struct tstat *curtpres; /* current present list */
static int curtlen; /* size of present list */
struct tstat *curpexit; /* exited process list */
struct tstat *devtstat; /* deviation list */
struct tstat **devpstat; /* pointers to processes */
/* in deviation list */
unsigned int ntaskpres; /* number of tasks present */
unsigned int nprocexit; /* number of exited procs */
unsigned int nprocexitnet; /* number of exited procs */
/* via netatopd daemon */
unsigned int ntaskdev; /* nr of tasks deviated */
unsigned int nprocdev; /* nr of procs deviated */
int nprocpres; /* nr of procs present */
int totrun, totslpi, totslpu, totzombie;
unsigned int noverflow;
/*
** initialization: allocate required memory dynamically
*/
cursstat = sstat_alloc("current sysstats");
presstat = sstat_alloc("prev sysstats");
devsstat = sstat_alloc("deviate sysstats");
curtlen = PROCMIN * 3 / 2; /* add 50% for threads */
curtpres = calloc(curtlen, sizeof(struct tstat));
ptrverify(curtpres, "Malloc failed for %d procstats\n", curtlen);
/*
** install the signal-handler for ALARM, USR1 and USR2 (triggers
** for the next sample)
*/
memset(&sigact, 0, sizeof sigact);
sigact.sa_handler = getusr1;
sigaction(SIGUSR1, &sigact, (struct sigaction *)0);
memset(&sigact, 0, sizeof sigact);
sigact.sa_handler = getusr2;
sigaction(SIGUSR2, &sigact, (struct sigaction *)0);
memset(&sigact, 0, sizeof sigact);
sigact.sa_handler = getalarm;
sigaction(SIGALRM, &sigact, (struct sigaction *)0);
if (interval.tv_sec || interval.tv_usec)
setalarm(&interval);
/*
** MAIN-LOOP:
** - Wait for the requested number of seconds or for other trigger
**
** - System-level counters
** get current counters
** calculate the differences with the previous sample
**
** - Process-level counters
** get current counters from running & exited processes
** calculate the differences with the previous sample
**
** - Call the print-function to visualize the differences
*/
for (sampcnt=0; sampcnt < nsamples; sampcnt++)
{
char lastcmd;
/*
** wait for alarm-signal to arrive (except first sample)
** or wait for SIGUSR1/SIGUSR2
*/
if (sampcnt > 0 && awaittrigger && !rawreadflag)
pause();
awaittrigger = 1;
/*
** take a snapshot of the current system-level statistics
*/
hlpsstat = cursstat; /* swap current/prev. stats */
cursstat = presstat;
presstat = hlpsstat;
photosyst(cursstat); /* obtain new counters */
/*
** take a snapshot of the current task-level statistics
**
** first register active tasks
** --> atop malloc's a minimal amount of space which is
** only extended when needed
*/
memset(curtpres, 0, curtlen * sizeof(struct tstat));
ntaskpres = photoproc(&curtpres, &curtlen);
/*
** register processes that exited during last sample;
** first determine how many processes exited
**
** the number of exited processes is limited to avoid
** that atop explodes in memory and introduces OOM killing
*/
nprocexit = acctprocnt(); /* number of exited processes */
if (nprocexit > MAXACCTPROCS)
{
noverflow = nprocexit - MAXACCTPROCS;
nprocexit = MAXACCTPROCS;
}
else
noverflow = 0;
/*
** determine how many processes have been exited
** for the netatop module (only processes that have
** used the network)
*/
if (nprocexit > 0 && (supportflags & NETATOPD))
nprocexitnet = netatop_exitstore();
else
nprocexitnet = 0;
/*
** reserve space for the exited processes and read them
*/
if (nprocexit > 0)
{
curpexit = malloc(nprocexit * sizeof(struct tstat));
ptrverify(curpexit,
"Malloc failed for %d exited processes\n",
nprocexit);
memset(curpexit, 0, nprocexit * sizeof(struct tstat));
nprocexit = acctphotoproc(curpexit, nprocexit);
/*
** reposition offset in accounting file when not
** all exited processes have been read (i.e. skip
** those processes)
*/
if (noverflow)
acctrepos(noverflow);
}
else
{
curpexit = NULL;
}
/*
** calculate the deviations (i.e. calculate the activity
** during the last sample). Note for PMAPI calls we had
** to delay changing curtime until after sampling due to
** the way pmSetMode(3) works.
*/
pretime = curtime; /* timestamp for previous sample */
curtime = cursstat->stamp; /* timestamp for this sample */
timed = __pmtimevalToReal(&curtime);
delta = timed - __pmtimevalToReal(&pretime);
deviatsyst(cursstat, presstat, devsstat, delta);
devtstat = malloc((ntaskpres+nprocexit) * sizeof(struct tstat));
ptrverify(devtstat, "Malloc failed for %d modified tasks\n",
ntaskpres+nprocexit);
ntaskdev = deviattask(curtpres, ntaskpres,
curpexit, nprocexit, deviatonly,
devtstat, devsstat,
&nprocdev, &nprocpres,
&totrun, &totslpi, &totslpu, &totzombie);
/*
** create list of pointers specifically to the process entries
** in the task list
*/
devpstat = malloc(sizeof (struct tstat *) * nprocdev);
ptrverify(devpstat, "Malloc failed for %d process ptrs\n",
nprocdev);
for (i=0, j=0; i < ntaskdev; i++)
{
if ( (devtstat+i)->gen.isproc)
devpstat[j++] = devtstat+i;
}
/*
** activate the installed print-function to visualize
** the deviations
*/
lastcmd = (vis.show_samp)(timed,
delta > 1.0 ? delta : 1.0,
devsstat, devtstat, devpstat,
ntaskdev, ntaskpres, nprocdev, nprocpres,
totrun, totslpi, totslpu, totzombie,
nprocexit, noverflow, sampcnt==0);
if (rawreadflag)
__pmtimevalInc(&curtime, &interval);
/*
** release dynamically allocated memory
*/
if (nprocexit > 0)
free(curpexit);
if (nprocexitnet > 0)
netatop_exiterase();
free(devtstat);
free(devpstat);
if (lastcmd == 'r') /* reset requested ? */
{
sampcnt = -1;
curtime = origin;
/* set current (will be 'previous') counters to 0 */
memset(curtpres, 0, curtlen * sizeof(struct tstat));
sstat_reset(cursstat);
/* remove all tasks in database */
pdb_makeresidue();
pdb_cleanresidue();
}
} /* end of main-loop */
}
/** disable **/
void disable() {
/* The timer is the only "interrut" -- so setting the timeout to
zero effectively disables "interrupts".
*/
setalarm(0);
}
