pitch check for clock being set wrong (almost ALWAYS WRONG)

[unix-history] / usr / src / local / sccscmds / sccscmds.ok / com / dodelt.c

#include        "../hdr/defines.h"

# define ONEYEAR 31536000L

SCCSID(@(#)dodelt       2.1);

long    Timenow;

char    Pgmr[SZLNAM];   /* for rmdel & chghist (rmchg) */
int     First_esc;

dodelt(pkt,statp,sidp,type)
register struct packet *pkt;
struct stats *statp;
struct sid *sidp;
char type;
{
       extern  char    *satoi();
       struct deltab dt;
       register struct idel *rdp;
       int n, founddel;
       long timediff;
       register char *p;

       pkt->p_idel = 0;
       founddel = 0;

       time(&Timenow);
       stats_ab(pkt,statp);
       while (getadel(pkt,&dt) == BDELTAB) {
               if (pkt->p_idel == 0) {
                       if (Timenow < dt.d_datetime)
                               fprintf(stderr,"Clock may be set wrong! (co11)");
                       timediff = Timenow - dt.d_datetime;
                       pkt->p_idel = alloc(n = ((dt.d_serial + 1) * sizeof(*pkt->p_idel)));
                       bzero(pkt->p_idel,n);
                       pkt->p_apply = alloc(n = ((dt.d_serial + 1) * sizeof(*pkt->p_apply)));
                       bzero(pkt->p_apply,n);
                       pkt->p_idel->i_pred = dt.d_serial;
               }
               if (dt.d_type == 'D') {
                       if (sidp && eqsid(&dt.d_sid,sidp)) {
                               copy(dt.d_pgmr,Pgmr);   /* for rmchg */
                               bzero(sidp,sizeof(*sidp));
                               founddel = 1;
                               First_esc = 1;
                               for (p = pkt->p_line; *p && *p != 'D'; p++)
                                       ;
                               if (*p)
                                       *p = type;
                       }
                       else
                               First_esc = founddel = 0;
                       pkt->p_maxr = max(pkt->p_maxr,dt.d_sid.s_rel);
                       rdp = &pkt->p_idel[dt.d_serial];
                       rdp->i_sid.s_rel = dt.d_sid.s_rel;
                       rdp->i_sid.s_lev = dt.d_sid.s_lev;
                       rdp->i_sid.s_br = dt.d_sid.s_br;
                       rdp->i_sid.s_seq = dt.d_sid.s_seq;
                       rdp->i_pred = dt.d_pred;
                       rdp->i_datetime = dt.d_datetime;
               }
               while ((n = getline(pkt)) != NULL)
                       if (pkt->p_line[0] != CTLCHAR)
                               break;
                       else {
                               switch (pkt->p_line[1]) {
                               case EDELTAB:
                                       break;
                               case COMMENTS:
                               case MRNUM:
                                       if (founddel)
                                               escdodelt(pkt);
                                       continue;
                               default:
                                       fmterr(pkt);
                               case INCLUDE:
                               case EXCLUDE:
                               case IGNORE:
                                       if (dt.d_type == 'D')
                                               doixg(pkt->p_line,&rdp->i_ixg);
                                       continue;
                               }
                               break;
                       }
               if (n == NULL || pkt->p_line[0] != CTLCHAR || getline(pkt) == NULL)
                       fmterr(pkt);
               if (pkt->p_line[0] != CTLCHAR || pkt->p_line[1] != STATS)
                       break;
       }
       return(pkt->p_idel);
}


getadel(pkt,dt)
register struct packet *pkt;
register struct deltab *dt;
{
       if (getline(pkt) == NULL)
               fmterr(pkt);
       return(del_ab(pkt->p_line,dt,pkt));
}


doixg(p,ixgp)
char *p;
struct ixg *ixgp;
{
       int *v, *ip;
       int type, cnt;
       struct ixg *cur, *prev;

       v = ip = alloca(BUFSIZ);
       ++p;
       type = *p++;
       NONBLANK(p);
       while (numeric(*p)) {
               p = satoi(p,ip++);
               NONBLANK(p);
       }
       cnt = ip - v;
       for (cur = ixgp; cur = (prev = cur)->i_next; )
               ;
       prev->i_next = cur = alloc(sizeof(*cur) + (cnt - 1) * sizeof(cur->i_ser[0]));
       cur->i_next = 0;
       cur->i_type = type;
       cur->i_cnt = cnt;
       bcopy(v,cur->i_ser,cnt * sizeof(cur->i_ser[0]));
}