# 2.11BSD#431 - /usr/src/new/notes/src/nfsend.c

##### Functions

    nfsend            X
    nfsendone         X

       1: #include "parms.h"
       2: #include "structs.h"
       3: #include "net.h"
       4: #ifdef  FASTSEQ
       5: #include    <sys/types.h>
       6: #include    <sys/stat.h>
       7: #endif	FASTSEQ
       8:
       9: #ifdef  RCSIDENT
      10: static char rcsid[] = "$Header: nfsend.c,v 1.7.0.1 85/08/04 12:16:32 notes Rel $";
      11: #endif	RCSIDENT
      12:
      13: /*
      14:  *	nfsend will send the notes/responses to a new site that
      15:  *	that site has not seen (at least as far as we are concerned)
      16:  *	This means that we send them the ones that we received later
      17:  *	then the last time we sent them, and also that were not
      18:  *	written there nor were routed through there.
      19:  *
      20:  *	Also, a logfile is maintained of the network transmissions made.
      21:  *
      22:  *	Returns:	-1 if the notefile is not a networked notefile
      23:  *			else count of articles sent
      24:  *
      25:  *	Original Coding:	Ray Essick	December 1981
      26:  */
      27:
      28: static struct io_f  io;
      29: static struct note_f    note;
      30: static struct resp_f    rsprec;
      31: static int  ncount,
      32:             rcount,                 /* how many of each sent */
      33:             num,
      34:             rrecnum,
      35:             roffset,
      36:             respnum;
      37: static  FILE * log,
      38:        *zfile;                      /* logfile stuff */
      39: static struct when_f    entered;
      40: static char line[DATELEN];              /* formatted date */
      41: static char fn[WDLEN];                  /* network log */
      42: static char scrfile[WDLEN];             /* scratch file */
      43: static char sendtime[DATELEN];              /* current time */
      44: static struct when_f    xsendtime;          /* raw current time */
      45: static int  traffic;                    /* if new traffic */
      46: static int  opened;                 /* for FASTSEQ */
      47:
      48: nfsend (tosite, nfname, dmpfile, usetime, sendhim, proto)
      49: char   *tosite,                     /* destination site */
      50:        *nfname,                     /* notefile sending */
      51:        *dmpfile;                    /* temp file */
      52: {
      53:
      54:     traffic = 0;                    /* idle */
      55:     opened = 0;                     /* FASTSEQ idle */
      56:     strcpy (scrfile, "");               /* mark as unused */
      57:     rcount = ncount = 0;                /* count sent */
      58:     gettime (&xsendtime);
      59:     sprdate (&xsendtime, sendtime);         /* format xmit time */
      60:     sprintf (Seqname, "Sy:%s", tosite);         /* sequencer name */
      61:
      62:
      63: #ifdef  FASTSEQ
      64:     {
      65:     struct when_f   whenvec;
      66:     char    NoteFile[WDLEN];
      67:     struct stat StatBuf;
      68:
      69:     if (nfname[0] == '/')               /* absolute pathname */
      70:     {
      71:         getlast (&io.stime, rindex (nfname, '/') + 1, usetime, Seqname);
      72:         sprintf (NoteFile, "%s/%s", nfname, TEXT);
      73:     }
      74:     else                        /* relative to Mstdir */
      75:     {
      76:         getlast (&io.stime, nfname, usetime, Seqname);
      77:         sprintf (NoteFile, "%s/%s/%s", Mstdir, nfname, TEXT);
      78:     }
      79:     if (stat (NoteFile, &StatBuf) >= 0)
      80:     {
      81:         maketime (&whenvec, (long) StatBuf.st_mtime);
      82:         if (inorder (&whenvec, &io.stime))
      83:         {
      84:         return (0);             /* nothing new */
      85:         }
      86:     }
      87:     }
      88: #endif	FASTSEQ
      89:
      90:     if (init (&io, nfname) < 0)
      91:     {
      92:     printf ("Couldn't open %s, try again later\n", nfname);
      93:     fflush (stdout);
      94:     return (-1);
      95:     }
      96:
      97:     opened++;                       /* nfsenddone will close */
      98:
      99:     getperms (&io, 1, tosite);              /* grab system name */
     100:     if (!allow (&io, READOK))               /* read permission? */
     101:     {
     102:     printf ("Site %s has no read permission for %s\n",
     103:         tosite, nfname);
     104:     fflush (stdout);
     105:     return (-1);                    /* and go back */
     106:     }
     107:
     108:     if ((io.descr.d_stat & NETWRKD) == 0)
     109:     {
     110:     printf ("Notefile %s is not networked\n", nfname);
     111:     fflush (stdout);
     112:     return (-1);
     113:     }
     114:
     115:
     116:     gettime (&entered);                 /* for seq. update */
     117:     getlast (&io.stime, io.nf, usetime, Seqname);   /* grab the time */
     118:
     119:     if (!inorder (&io.stime, &io.descr.d_lastm))    /* something new */
     120:     {                           /* idle notesfile */
     121: #ifdef  FASTSEQ
     122: /*
     123:  *	update the sequencer so the next pass through will be
     124:  *	caught by the FASTSEQ test which just stats the file.
     125:  */
     126:     fixlast (&entered, io.nf, NORMSEQ, Seqname);    /* update sequencer */
     127: #endif	FASTSEQ
     128:     return (0);
     129:     }
     130: /*
     131:  *	reach here only if we have potential traffic
     132:  *	and permission to send it.
     133:  */
     134:     traffic++;                      /* forces seq update */
     135:
     136:     x ((zfile = fopen (dmpfile, "w")) == NULL, "nfsend: scratch");
     137:     strcpy (scrfile, dmpfile);              /* save scratch name */
     138:     num = 0;                        /* start at the beginning */
     139:     while ((num = nxtnote (&io, num, &io.stime)) != -1)
     140:     {
     141:     getnrec (&io, num, &note);          /* grab the header */
     142:     if (!strcmp (note.n_from, tosite) && !(sendhim & SENDHIS))
     143:         goto doresps;               /* they sent it to us */
     144:     if (!strcmp (note.n_id.sys, tosite) && !(sendhim & SENDHIS))
     145:         goto doresps;               /* written there */
     146:     if (inorder (&io.stime, &note.n_rcvd) == 0)
     147:         goto doresps;               /* only modified */
     148:     if ((note.n_stat & FRMNEWS) && !(sendhim & SENDNEWS))/* DO NOT send news */
     149:         goto doresps;               /* causes uniqid probs */
     150: #ifdef  notdef
     151:     /*
     152: 	 * we want to send foster parents so they will have a title on
     153: 	 * the remote end.
     154: 	 */
     155:     if (note.n_stat & ORPHND)           /* no foster parents */
     156:         goto doresps;               /* should have copy */
     157: #endif	notdef
     158:     dmpnote (&io, &note, num, zfile, NODETAIL, proto);/* dump to output */
     159:     ncount++;                   /* bump count of sent articles */
     160:     io.nnotxmit++;                  /* and global stats */
     161:
     162: doresps:                        /* process the responses */
     163:     respnum = 0;
     164:     while ((respnum = nxtresp (&io, num, respnum, &io.stime)) != -1)
     165:     {
     166:         if (lrsp (&io, num, respnum, &rsprec, &roffset, &rrecnum) == -1)
     167:         break;                  /* no response */
     168:         if (!strcmp (rsprec.r_id[roffset].sys, tosite) && !(sendhim & SENDHIS))
     169:         continue;               /* written there */
     170:         if (!strcmp (rsprec.r_from[roffset], tosite) && !(sendhim & SENDHIS))
     171:         continue;               /* came through there */
     172:         if ((rsprec.r_stat[roffset] & FRMNEWS) && !(sendhim & SENDNEWS))
     173:         continue;               /* never forward NEWS(I) stuff */
     174:         dmprsp (&io, &note, num, zfile, respnum, NODETAIL, proto);
     175:         rcount++;
     176:         io.nrspxmit++;              /* and global stats */
     177:     }
     178:     }
     179:     fclose (zfile);                 /* and the dumping file */
     180:     return (ncount + rcount);
     181: }
     182:
     183: /*
     184:  *	nfsendone fixes up the sequencer entry for the system/notesfile
     185:  *	pair. The sequencer is only updated if the transmission
     186:  *	was successful (as determined by the retval parameter.
     187:  *
     188:  *	Thanks to Malcolm Slaney for this one.
     189:  */
     190:
     191: nfsendone (nfname, tosite, queuestat, sendstat)
     192: char   *tosite;                     /* Name of site */
     193: char   *nfname;                     /* Name of notesfile */
     194: int     queuestat;                  /* Unix return value */
     195: {
     196:
     197: /*
     198:  *	Traffic is non-zero if something happened in that notesfile
     199:  *	If nothing at all happened, we save the bother of updating
     200:  *	since it doesn't save us any scanning time later.
     201:  *	(and not updating does save us a little time now)
     202:  *
     203:  *	We check queuestat because we don't want to update the
     204:  *	sequencer file if we know that the transmission failed.
     205:  */
     206:     if (traffic && (!queuestat))            /* only if non-idle */
     207:     {
     208:     fixlast (&entered, io.nf, NORMSEQ, Seqname);    /* update sequencer */
     209:     }
     210:
     211: /*
     212:  *	Update statistics only on successful non-empty transmissions.
     213:  *	We don't do any statistics for empty transmissions
     214:  */
     215: #ifdef  STATS
     216:     if ((!queuestat) && (sendstat > 0))         /* if it worked */
     217:     {                           /* and sent */
     218:     locknf (&io, DSCRLOCK);
     219:     getdscr (&io, &io.descr);
     220:     gettime (&io.descr.d_lstxmit);          /* mark as sent now */
     221:     if (ncount + rcount > 0)            /* only if sent stuff */
     222:         io.descr.netwrkouts++;          /* increment xmits */
     223:     putdscr (&io, &io.descr);
     224:     unlocknf (&io, DSCRLOCK);
     225:     }
     226: #endif	STATS
     227:
     228:     if (opened)                     /* did init(&io,nf) */
     229:     finish (&io);                   /* so close it */
     230: /*
     231:  *	Now log everything that happened
     232:  */
     233:
     234:     sprdate (&io.stime, line);
     235:     sprintf (fn, "%s/%s/%s", Mstdir, UTILITY, NETLOG);  /* logging */
     236:     if (sendstat >= 0)                  /* no bizarre errors */
     237:     {
     238:     if (ncount + rcount)                /* log only if sending */
     239:     {
     240:         x ((log = fopen (fn, "a")) == NULL, "nfsend: bad net log file");
     241:         fprintf (log, "%s: %s send (%3d,%3d) to %-10s at %s\n",
     242:             nfname, queuestat ? "Fail" : "Did", ncount, rcount,
     243:             tosite, sendtime);
     244:         x (fclose (log) == EOF, "nfsend: trouble fclosing log file");
     245:         printf ("%-14s: %4s send (%3d,%3d) to %s since %s\n",
     246:             nfname, queuestat ? "Fail" : "Did", ncount, rcount,
     247:             tosite, line);
     248:     }
     249:     else
     250:     {
     251:         printf ("%-14s: No new notes since %s\n", nfname, line);
     252:     }
     253:     fflush (stdout);                /* force it out */
     254:
     255:     }
     256:
     257:     if (strcmp (scrfile, "") != 0)          /* contains a name */
     258:     {
     259:     unlink (scrfile);               /* don't leave droppings */
     260:     }
     261:
     262: }

#### Defined functions

nfsend defined in line 48; used 1 times

- in /usr/src/new/notes/src/nfxmit.c line 61

nfsendone defined in line 191; used 1 times

- in /usr/src/new/notes/src/nfxmit.c line 87

#### Defined variables

entered defined in line 39; used 3 times

- in line 116, 126, 208

fn defined in line 41; used 2 times

- in line 235-240(2)

io defined in line 28; used 34 times

- in line 71-76(2), 82, 90, 99-100(2), 108, 117-119(4), 126, 139-146(4), 158-166(5), 174-176(2), 208, 218-234(10)

line defined in line 40; used 3 times

- in line 234, 247-251(2)

ncount defined in line 31; used 7 times

- in line 57, 159, 180, 221, 238-246(3)

note defined in line 29; used 8 times

- in line 141-148(5), 155-158(2), 174

num defined in line 33; used 8 times

- in line 138-141(4), 158, 164-166(2), 174

opened defined in line 46; used 3 times

- in line 55, 97, 228

rcount defined in line 32; used 7 times

- in line 57, 175-180(2), 221, 238-246(3)

rcsid defined in line 10; never used
respnum defined in line 36; used 5 times

- in line 163-166(4), 174

roffset defined in line 35; used 4 times

- in line 166-172(4)

rrecnum defined in line 34; used 1 times

- in line 166

rsprec defined in line 30; used 4 times

- in line 166-172(4)

scrfile defined in line 42; used 4 times

- in line 56, 137, 257-259(2)

sendtime defined in line 43; used 2 times

- in line 59, 243

traffic defined in line 45; used 3 times

- in line 54, 134, 206

xsendtime defined in line 44; used 2 times

- in line 58-59(2)

Last modified: 1988-03-29 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1085 |