Return to spool.c CVS log

Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 / unix

Annotation of coherent/g/usr/lib/uucp/tay104/unix/spool.c, revision 1.1

1.1     ! root        1: /* spool.c
        !             2:    Find a file in the spool directory.
        !             3: 
        !             4:    Copyright (C) 1991, 1992 Ian Lance Taylor
        !             5: 
        !             6:    This file is part of the Taylor UUCP package.
        !             7: 
        !             8:    This program is free software; you can redistribute it and/or
        !             9:    modify it under the terms of the GNU General Public License as
        !            10:    published by the Free Software Foundation; either version 2 of the
        !            11:    License, or (at your option) any later version.
        !            12: 
        !            13:    This program is distributed in the hope that it will be useful, but
        !            14:    WITHOUT ANY WARRANTY; without even the implied warranty of
        !            15:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
        !            16:    General Public License for more details.
        !            17: 
        !            18:    You should have received a copy of the GNU General Public License
        !            19:    along with this program; if not, write to the Free Software
        !            20:    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
        !            21: 
        !            22:    The author of the program may be contacted at [email protected] or
        !            23:    c/o Infinity Development Systems, P.O. Box 520, Waltham, MA 02254.
        !            24:    */
        !            25: 
        !            26: #include "uucp.h"
        !            27: 
        !            28: #if USE_RCS_ID
        !            29: const char spool_rcsid[] = "$Id: spool.c,v 1.1 93/07/30 08:03:28 bin Exp Locker: bin $";
        !            30: #endif
        !            31: 
        !            32: #include "uudefs.h"
        !            33: #include "sysdep.h"
        !            34: #include "system.h"
        !            35: 
        !            36: /* There are several types of files that go in the spool directory,
        !            37:    and they go into various different subdirectories.  Whenever the
        !            38:    system name LOCAL appears below, it means whatever the local system
        !            39:    name is.
        !            40: 
        !            41:    Command files
        !            42:    These contain instructions for uucico indicating what files to transfer
        !            43:    to and from what systems.  Each line of a work file is a command
        !            44:    beginning with S, R or X.
        !            45:    #if ! SPOOLDIR_TAYLOR
        !            46:    They are named C.ssssssgqqqq, where ssssss is the system name to
        !            47:    transfer to or from, g is the grade and qqqq is the sequence number.
        !            48:    #if SPOOLDIR_V2
        !            49:    They are put in the spool directory.
        !            50:    #elif SPOOLDIR_BSD42 || SPOOLDIR_BSD43
        !            51:    They are put in the directory "C.".
        !            52:    #elif SPOOLDIR_HDB
        !            53:    They are put in a directory named for the system for which they were
        !            54:    created.
        !            55:    #elif SPOOLDIR_ULTRIX
        !            56:    If the directory sys/ssssss exists, they are put in the directory
        !            57:    sys/ssssss/C; otherwise, they are put in the directory sys/DEFAULT/C.
        !            58:    #endif
        !            59:    #elif SPOOLDIR_SVR4
        !            60:    They are put in the directory sys/g, where sys is the system name
        !            61:    and g is the grade.
        !            62:    #endif
        !            63:    #else SPOOLDIR_TAYLOR
        !            64:    They are named C.gqqqq, where g is the grade and qqqq is the sequence
        !            65:    number, and are placed in the directory ssssss/C. where ssssss is
        !            66:    the system name to transfer to or from.
        !            67:    #endif
        !            68: 
        !            69:    Data files
        !            70:    There are files to be transferred to other systems.  Some files to
        !            71:    be transferred may not be in the spool directory, depending on how
        !            72:    uucp was invoked.  Data files are named in work files, so it is
        !            73:    never necessary to look at them directly (except to remove old ones);
        !            74:    it is only necessary to create them.  These means that the many
        !            75:    variations in naming are inconsequential.
        !            76:    #if ! SPOOLDIR_TAYLOR
        !            77:    They are named D.ssssssgqqqq where ssssss is a system name (which
        !            78:    may be LOCAL for locally initiated transfers or a remote system for
        !            79:    remotely initiated transfers, except that HDB appears to use the
        !            80:    system the file is being transferred to), g is the grade and qqqq
        !            81:    is the sequence number.  Some systems use a trailing subjob ID
        !            82:    number, but we currently do not.  The grade is not important, and
        !            83:    some systems do not use it.  If the data file is to become an
        !            84:    execution file on another system the grade (if present) will be
        !            85:    'X'.  Otherwise Ultrix appears to use 'b'; the uux included with
        !            86:    gnuucp 1.0 appears to use 'S'; SCO does not appear to use a grade,
        !            87:    although it does use a subjob ID number.
        !            88:    #if SPOOLDIR_V2
        !            89:    They are put in the spool directory.
        !            90:    #elif SPOOLDIR_BSD42
        !            91:    If the name begins with D.LOCAL, the file is put in the directory
        !            92:    D.LOCAL.  Otherwise the file is put in the directory D..
        !            93:    #elif SPOOLDIR_BSD43
        !            94:    If the name begins with D.LOCALX, the file is put in the directory
        !            95:    D.LOCALX.  Otherwise if the name begins with D.LOCAL, the file is
        !            96:    put in the directory D.LOCAL Otherwise the file is put in the
        !            97:    directory "D.".
        !            98:    #elif SPOOLDIR_HDB
        !            99:    They are put in a directory named for the system for which they
        !           100:    were created.
        !           101:    #elif SPOOLDIR_ULTRIX
        !           102:    Say the file is being transferred to system REMOTE.  If the
        !           103:    directory sys/REMOTE exists, then if the file begins with D.LOCALX
        !           104:    it is put in sys/REMOTE/D.LOCALX, if the file begins with D.LOCAL
        !           105:    it is put in sys/REMOTE/D.LOCAL, and otherwise it is put in
        !           106:    "sys/REMOTE/D.".  If the directory sys/REMOTE does not exist, the
        !           107:    same applies except that DEFAULT is used instead of REMOTE.
        !           108:    #elif SPOOLDIR_SVR4
        !           109:    They are put in the directory sys/g, where sys is the system name
        !           110:    and g is the grade.
        !           111:    #endif
        !           112:    #else SPOOLDIR_TAYLOR
        !           113:    If the file is to become an executable file on another system it is
        !           114:    named D.Xqqqq, otherwise it is named D.qqqq where in both cases
        !           115:    qqqq is a sequence number.  If the corresponding C. file is in
        !           116:    directory ssssss/C., a D.X file is placed in ssssss/D.X and a D.
        !           117:    file is placed in "ssssss/D.".
        !           118:    #endif
        !           119: 
        !           120:    Execute files
        !           121:    These are files that specify programs to be executed.  They are
        !           122:    created by uux, perhaps as run on another system.  These names are
        !           123:    important, because a file transfer done to an execute file name
        !           124:    causes an execution to occur.  The name is X.ssssssgqqqq, where
        !           125:    ssssss is the requesting system, g is the grade, and qqqq is a
        !           126:    sequence number.
        !           127:    #if SPOOLDIR_V2 || SPOOLDIR_BSD42
        !           128:    These files are placed in the spool directory.
        !           129:    #elif SPOOLDIR_BSD43
        !           130:    These files are placed in the directory X..
        !           131:    #elif SPOOLDIR_HDB || SPOOLDIR_SVR4
        !           132:    These files are put in a directory named for the system for which
        !           133:    the files were created.
        !           134:    #elif SPOOLDIR_ULTRIX
        !           135:    If there is a spool directory (sys/ssssss) for the requesting
        !           136:    system, the files are placed in sys/ssssss/X.; otherwise, the files
        !           137:    are placed in "sys/DEFAULT/X.".
        !           138:    #elif SPOOLDIR_TAYLOR
        !           139:    The system name is automatically truncated to seven characters when
        !           140:    a file is created.  The files are placed in the subdirectory X. of
        !           141:    a directory named for the system for which the files were created.
        !           142:    #endif
        !           143: 
        !           144:    Temporary receive files
        !           145:    These are used when receiving files from another system.  They are
        !           146:    later renamed to the final name.  The actual name is unimportant,
        !           147:    although it generally begins with TM..
        !           148:    #if SPOOLDIR_V2 || SPOOLDIR_BSD42
        !           149:    These files are placed in the spool directory.
        !           150:    #elif SPOOLDIR_BSD43 || SPOOLDIR_ULTRIX || SPOOLDIR_TAYLOR
        !           151:    These files are placed in the directory .Temp.
        !           152:    #elif SPOOLDIR_HDB || SPOOLDIR_SVR4
        !           153:    These files are placed in a directory named for the system for
        !           154:    which they were created.
        !           155:    #endif
        !           156: 
        !           157:    System status files
        !           158:    These are used to record when the last call was made to the system
        !           159:    and what the status is.  They are used to prevent frequent recalls
        !           160:    to a system which is not responding.  I will not attempt to
        !           161:    recreate the format of these exactly, since they are not all that
        !           162:    important.  They will be put in the directory .Status, as in HDB,
        !           163:    and they use the system name as the name of the file.
        !           164: 
        !           165:    Sequence file
        !           166:    This is used to generate a unique sequence number.  It contains an
        !           167:    ASCII number.
        !           168:    #if SPOOLDIR_V2 || SPOOLDIR_BSD42 || SPOOLDIR_BSD43
        !           169:    The file is named SEQF and is kept in the spool directory.
        !           170:    #elif SPOOLDIR_HDB || SPOOLDIR_SVR4
        !           171:    A separate sequence file is kept for each system in the directory
        !           172:    .Sequence with the name of the system.
        !           173:    #elif SPOOLDIR_ULTRIX
        !           174:    Each system with a file sys/ssssss has a sequence file in
        !           175:    sys/ssssss/.SEQF.  Other systems use sys/DEFAULT/.SEQF.
        !           176:    #else SPOOLDIR_TAYLOR
        !           177:    A sequence file named SEQF is kept in the directory ssssss for each
        !           178:    system.
        !           179:    #endif
        !           180:    */
        !           181: 
        !           182: /* Given the name of a file as specified in a UUCP command, and the
        !           183:    system for which this file has been created, return where to find
        !           184:    it in the spool directory.  The file will begin with C. (a command
        !           185:    file), D. (a data file) or X. (an execution file).  Under
        !           186:    SPOOLDIR_SVR4 we need to know the grade of the file created by the
        !           187:    local system; this is the bgrade argument, which is -1 for a file
        !           188:    from a remote system.  */
        !           189: 
        !           190: /*ARGSUSED*/
        !           191: char *
        !           192: zsfind_file (zsimple, zsystem, bgrade)
        !           193:      const char *zsimple;
        !           194:      const char *zsystem;
        !           195:      int bgrade;
        !           196: {
        !           197:   if (! fspool_file (zsimple))
        !           198:     {
        !           199:       ulog (LOG_ERROR, "Unrecognized file name %s", zsimple);
        !           200:       return NULL;
        !           201:     }
        !           202: 
        !           203: #if ! SPOOLDIR_HDB && ! SPOOLDIR_SVR4 && ! SPOOLDIR_TAYLOR
        !           204:   if (*zsimple == 'X')
        !           205:     {
        !           206:       size_t clen;
        !           207: 
        !           208:       /* Files beginning with X. are execute files.  It is important
        !           209:         for security reasons that we know the system which created
        !           210:         the X. file.  This is easy under SPOOLDIR_HDB or
        !           211:         SPOOLDIR_SVR4 SPOOLDIR_TAYLOR, because the file will be in a
        !           212:         directory named for the system.  Under other schemes, we must
        !           213:         get the system name from the X. file name.  To prevent
        !           214:         security violations, we set the system name directly here;
        !           215:         this will cause problems if the maximum file name length is
        !           216:         too short, but hopefully no problem will occur since any
        !           217:         System V systems will be using HDB or SVR4 or TAYLOR.  */
        !           218:       clen = strlen (zsimple);
        !           219:       if (clen <= 7 || strncmp (zsimple + 2, zsystem, clen - 7) != 0)
        !           220:        {
        !           221:          static char *zbuf;
        !           222:          static size_t cbuf;
        !           223:          size_t cwant;
        !           224: 
        !           225:          cwant = strlen (zsystem) + 8;
        !           226:          if (cwant > cbuf)
        !           227:            {
        !           228:              zbuf = (char *) xrealloc ((pointer) zbuf, cwant);
        !           229:              cbuf = cwant;
        !           230:            }
        !           231:          sprintf (zbuf, "X.%s%s", zsystem,
        !           232:                   clen < 5 ? zsimple : zsimple + clen - 5);
        !           233:          zsimple = zbuf;
        !           234:        }
        !           235:     }
        !           236: #endif /* ! SPOOLDIR_HDB && ! SPOOLDIR_SVR4 && ! SPOOLDIR_TAYLOR */
        !           237: 
        !           238: #if SPOOLDIR_V2
        !           239:   /* V2 never uses subdirectories.  */
        !           240:   return zbufcpy (zsimple);
        !           241: #endif /* SPOOLDIR_V2 */
        !           242: 
        !           243: #if SPOOLDIR_HDB
        !           244:   /* HDB always uses the system name as a directory.  */
        !           245:   return zsysdep_in_dir (zsystem, zsimple);
        !           246: #endif /* SPOOLDIR_HDB */
        !           247: 
        !           248: #if SPOOLDIR_SVR4
        !           249:   /* SVR4 uses grade directories within the system directory for local
        !           250:      command and data files.  */
        !           251:   if (bgrade < 0 || *zsimple == 'X')
        !           252:     return zsysdep_in_dir (zsystem, zsimple);
        !           253:   else
        !           254:     {
        !           255:       char abgrade[2];
        !           256: 
        !           257:       abgrade[0] = bgrade;
        !           258:       abgrade[1] = '\0';
        !           259:       return zsappend3 (zsystem, abgrade, zsimple);
        !           260:     }
        !           261: #endif /* SPOOLDIR_SVR4 */
        !           262: 
        !           263: #if ! SPOOLDIR_V2 && ! SPOOLDIR_HDB && ! SPOOLDIR_SVR4
        !           264:   switch (*zsimple)
        !           265:     {
        !           266:     case 'C':
        !           267: #if SPOOLDIR_BSD42 || SPOOLDIR_BSD43
        !           268:       return zsysdep_in_dir ("C.", zsimple);
        !           269: #endif /* SPOOLDIR_BSD42 || SPOOLDIR_BSD43 */
        !           270: #if SPOOLDIR_ULTRIX
        !           271:       if (fsultrix_has_spool (zsystem))
        !           272:        return zsappend4 ("sys", zsystem, "C.", zsimple);
        !           273:       else
        !           274:        return zsappend4 ("sys", "DEFAULT", "C.", zsimple);
        !           275: #endif /* SPOOLDIR_ULTRIX */
        !           276: #if SPOOLDIR_TAYLOR
        !           277:       return zsappend3 (zsystem, "C.", zsimple);
        !           278: #endif /* SPOOLDIR_TAYLOR */
        !           279: 
        !           280:     case 'D':
        !           281: #if SPOOLDIR_BSD42 || SPOOLDIR_BSD43
        !           282:       {
        !           283:        size_t c;
        !           284:        boolean ftruncated;
        !           285:       
        !           286:        /* D.LOCAL in D.LOCAL/, others in D./.  If BSD43, D.LOCALX in
        !           287:           D.LOCALX/.  */
        !           288:        ftruncated = TRUE;
        !           289:        if (strncmp (zsimple + 2, zSlocalname, strlen (zSlocalname)) == 0)
        !           290:          {
        !           291:            c = strlen (zSlocalname);
        !           292:            ftruncated = FALSE;
        !           293:          }
        !           294:        else if (strncmp (zsimple + 2, zSlocalname, 7) == 0)
        !           295:          c = 7;
        !           296:        else if (strncmp (zsimple + 2, zSlocalname, 6) == 0)
        !           297:          c = 6;
        !           298:        else
        !           299:          c = 0;
        !           300: #if SPOOLDIR_BSD43
        !           301:        if (c > 0 && zsimple[c + 2] == 'X')
        !           302:          c++;
        !           303: #endif /* SPOOLDIR_BSD43 */
        !           304:        if (c > 0)
        !           305:          {
        !           306:            char *zalloc;
        !           307: 
        !           308:            zalloc = zbufalc (c + 3);
        !           309:            memcpy (zalloc, zsimple, c + 2);
        !           310:            zalloc[c + 2] = '\0';
        !           311: 
        !           312:            /* If we truncated the system name, and there is no existing
        !           313:               directory with the truncated name, then just use D..  */
        !           314:            if (! ftruncated || fsysdep_directory (zalloc))
        !           315:              {
        !           316:                char *zret;
        !           317: 
        !           318:                zret = zsysdep_in_dir (zalloc, zsimple);
        !           319:                ubuffree (zalloc);
        !           320:                return zret;
        !           321:              }
        !           322:            ubuffree (zalloc);
        !           323:          }
        !           324:        return zsysdep_in_dir ("D.", zsimple);
        !           325:       }
        !           326: #endif /* SPOOLDIR_BSD42 || SPOOLDIR_BSD43 */
        !           327: #if SPOOLDIR_ULTRIX
        !           328:       {
        !           329:        size_t c;
        !           330:        boolean ftruncated;
        !           331:        char *zfree;
        !           332:        const char *zdir;
        !           333:        char *zret;
        !           334:       
        !           335:        /* D.LOCALX in D.LOCALX/, D.LOCAL in D.LOCAL/, others in D./.  */
        !           336:        ftruncated = TRUE;
        !           337:        if (strncmp (zsimple + 2, zSlocalname, strlen (zSlocalname)) == 0)
        !           338:          {
        !           339:            c = strlen (zSlocalname);
        !           340:            ftruncated = FALSE;
        !           341:          }
        !           342:        else if (strncmp (zsimple + 2, zSlocalname, 7) == 0)
        !           343:          c = 7;
        !           344:        else if (strncmp (zsimple + 2, zSlocalname, 6) == 0)
        !           345:          c = 6;
        !           346:        else
        !           347:          c = 0;
        !           348:        if (c > 0 && zsimple[c + 2] == 'X')
        !           349:          ++c;
        !           350:        if (c > 0)
        !           351:          {
        !           352:            zfree = zbufalc (c + 3);
        !           353:            memcpy (zfree, zsimple, c + 2);
        !           354:            zfree[c + 2] = '\0';
        !           355:            zdir = zfree;
        !           356: 
        !           357:            /* If we truncated the name, and there is no directory for
        !           358:               the truncated name, then don't use it.  */
        !           359:            if (ftruncated)
        !           360:              {
        !           361:                char *zlook;
        !           362: 
        !           363:                zlook = zsappend3 ("sys",
        !           364:                                   (fsultrix_has_spool (zsystem)
        !           365:                                    ? zsystem
        !           366:                                    : "DEFAULT"),
        !           367:                                   zdir);
        !           368:                if (! fsysdep_directory (zlook))
        !           369:                  zdir = "D.";
        !           370:                ubuffree (zlook);
        !           371:              }
        !           372:          }
        !           373:        else
        !           374:          {
        !           375:            zfree = NULL;
        !           376:            zdir = "D.";
        !           377:          }
        !           378:       
        !           379:        zret = zsappend4 ("sys",
        !           380:                          (fsultrix_has_spool (zsystem)
        !           381:                           ? zsystem
        !           382:                           : "DEFAULT"),
        !           383:                          zdir,
        !           384:                          zsimple);
        !           385:        ubuffree (zfree);
        !           386:        return zret;
        !           387:       }
        !           388: #endif /* SPOOLDIR_ULTRIX */
        !           389: #if SPOOLDIR_TAYLOR
        !           390:       if (zsimple[2] == 'X')
        !           391:        return zsappend3 (zsystem, "D.X", zsimple);
        !           392:       else
        !           393:        return zsappend3 (zsystem, "D.", zsimple);
        !           394: #endif /* SPOOLDIR_TAYLOR */
        !           395: 
        !           396: 
        !           397:     case 'X':
        !           398: #if SPOOLDIR_BSD42
        !           399:       return zbufcpy (zsimple);
        !           400: #endif
        !           401: #if SPOOLDIR_BSD43
        !           402:       return zsysdep_in_dir ("X.", zsimple);
        !           403: #endif
        !           404: #if SPOOLDIR_ULTRIX
        !           405:       return zsappend4 ("sys",
        !           406:                        (fsultrix_has_spool (zsystem)
        !           407:                         ? zsystem
        !           408:                         : "DEFAULT"),
        !           409:                        "X.",
        !           410:                        zsimple);
        !           411: #endif
        !           412: #if SPOOLDIR_TAYLOR
        !           413:       return zsappend3 (zsystem, "X.", zsimple);
        !           414: #endif
        !           415:     }
        !           416: 
        !           417:   /* This is just to avoid warnings; it will never be executed.  */
        !           418:   return NULL;
        !           419: #endif /* ! SPOOLDIR_V2 && ! SPOOLDIR_HDB && ! SPOOLDIR_SVR4 */
        !           420: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.