import.c

汇编源代码大全

/*--------------------------------------------------------------------*/
/*    i m p o r t . c                                                 */
/*                                                                    */
/*    File name mapping routines for UUPC/extended                    */
/*--------------------------------------------------------------------*/

/*--------------------------------------------------------------------*/
/*    Changes Copyright (c) 1989 by Andrew H. Derbyshire.             */
/*                                                                    */
/*    Changes Copyright (c) 1990-1993 by Kendra Electronic            */
/*    Wonderworks.                                                    */
/*                                                                    */
/*    All rights reserved except those explicitly granted by the      */
/*    UUPC/extended license agreement.                                */
/*--------------------------------------------------------------------*/

/*
 *    $Id: import.c 1.9 1993/09/27 04:04:06 ahd Exp $
 *
 *    $Log: import.c $
 *     Revision 1.9  1993/09/27  04:04:06  ahd
 *     Correct creation of pointer to file system name
 *
 *     Revision 1.8  1993/09/26  03:32:27  dmwatt
 *     Use Standard Windows NT error message module
 *
 *     Revision 1.7  1993/09/20  04:38:11  ahd
 *     TCP/IP support from Dave Watt
 *     't' protocol support
 *     OS/2 2.x support
 *
 *     Revision 1.6  1993/09/03  12:54:55  ahd
 *     Add missing endif
 *
 *     Revision 1.5  1993/09/03  12:18:55  dmwatt
 *     Windows NT support for long names on file systems
 *
 *     Revision 1.4  1993/09/02  12:08:17  ahd
 *     HPFS Support
 *
 *     Revision 1.3  1993/04/11  00:31:31  dmwatt
 *     Global edits for year, TEXT, etc.
 *
 * Revision 1.2  1992/11/22  21:06:14  ahd
 * Correct mapping of dos paths with trailing slashes
 *
 */

/*--------------------------------------------------------------------*/
/*                        System include files                        */
/*--------------------------------------------------------------------*/

#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#if defined(FAMILYAPI) || defined(__OS2__)
#define INCL_NOPM             // No need to include OS/2 PM info
#define INCL_BASE
#include <os2.h>
#elif defined(WIN32)
#include <windows.h>
#endif

/*--------------------------------------------------------------------*/
/*                    UUPC/extended include files                     */
/*--------------------------------------------------------------------*/

#include "lib.h"
#include "import.h"
#include "arbmath.h"
#include "hostable.h"
#include "usertabl.h"
#include "security.h"

#ifdef WIN32
#include "pnterr.h"
#endif

#define MAX_DIGITS 20         /* Number of digits for arb math */

/*--------------------------------------------------------------------*/
/*                    Internal function prototypes                    */
/*--------------------------------------------------------------------*/

#define min(x,y) (((x) < (y)) ? (x) : (y))

currentfile();

/*--------------------------------------------------------------------*/
/*                     Local function prototypes                      */
/*--------------------------------------------------------------------*/

static void ImportName( char *local,
                        const char *canon,
                        size_t charsetsize,
                        const boolean longname );

static boolean advancedFS( const char *path );

/*-------------------------------------------------------------------*/
/*                                                                   */
/*   i m p o r t p a t h                                             */
/*                                                                   */
/*   Convert a canonical name to a format the host can handle        */
/*                                                                   */
/*   These routines convert file name between canonical form, which  */
/*   is defined as a 'unix' style pathname, and the MS-DOS all       */
/*   uppercase "xxxxxxxx.xxx" format.                                */
/*                                                                   */
/*   If the canonical name does not have a path, that is the file is */
/*   destined for the local spool directory, we can assume the UNIX  */
/*   name will normally be in a format like this:                    */
/*                                                                   */
/*                                                                   */
/*       X.hostid#######            (Execute files)                  */
/*       C.hostid#######            (Call files)                     */
/*       D.hostid#######            (Data files)                     */
/*                                                                   */
/*   where "hostid" may be most, but not always all, of the local    */
/*   host or remote host (the file came from or is going to) and     */
/*   "######" can be any character valid for the UNIX file system.   */
/*   Note, however, that the routine has to be generic to allow for  */
/*   other file names to be placed in the spool directory without    */
/*   collisions.                                                     */
/*                                                                   */
/*   Avoiding collisions in the spool directory is important; when   */
/*   receiving files with mixed case names longer than 11            */
/*   characters, sooner or later a file name collision will occur.   */
/*                                                                   */
/*   We can also assume that only UUPC will see these names, which   */
/*   means we can transform the name using any method we choose, so  */
/*   long as the UUPC functions opening the file always call         */
/*   importpath, and that importpath is reducible (that is, two      */
/*   calls to importpath with the same argument always yield the     */
/*   same result).  Note that if end user really wanted the file in  */
/*   the spool directory, all he has to do is rename the file-- far  */
/*   better than losing the data because duplicate file names.       */
/*                                                                   */
/*   For these files, we map the name as follows:                    */
/*                                                                   */
/*   0 - If the name is a valid MS-DOS name, use it without changing */
/*                                                                   */
/*   1 - Begin the output name by inserting up to the first eight    */
/*       characters of the remote host name (followed by a slash) as */
/*       a subdirectory name.                                        */
/*                                                                   */
/*   2 - If the input name begins with an uppercase alphabetic       */
/*       character followed by a period, also insert the alphabetic  */
/*       (followed by a slash) to make this a second subdirectory.   */
/*       Then, move the logical start of the input name past the two */
/*       characters.                                                 */
/*                                                                   */
/*   3 - Determine the number of characters the local host and       */
/*       remote hosts have equal to the next characters of the input */
/*       name, up to a maximum of 8, and zero the lower of the two   */
/*       counts.  Then, step past the number of characters of the    */
/*       larger count.                                               */
/*                                                                   */
/*       For example, if the file name is X.keane22222 and the local */
/*       host name is kendra (2 characters match) and the remote     */
/*       host is keane1 (5 characters match), zero the number of     */
/*       characters matched by kendra, and make the new start of the */
/*       file name five characters further (at the first "2").       */
/*                                                                   */
/*   4 - Convert the remaining string using a base conversion, with  */
/*       the input character size being from ascii "#" to ascii "z"  */
/*       (88 characters) to the allowed set of characters in MS-DOS  */
/*       file names (charset, below, 52 characters).                 */
/*                                                                   */
/*   5 - Prepend to the string to be converted the length of the     */
/*       remote host added to the length of the local host           */
/*       multiplied by 8 (both lengths were computed in step 3,      */
/*       above).  The base conversion is also applied to this        */
/*       "character", we which know will be in the range 1-64.       */
/*                                                                   */
/*   6 - If the string created by steps 4 and 5 exceeds 8            */
/*       characters, insert a period after the eighth character to   */
/*       make it a valid MS-DOS file name.  If the string created by */
/*       steps 4 and 5 exceeds 11 characters, truncate the string by */
/*       using the first eight and last three characters.            */
/*                                                                   */
/*   7 - Append the string created in steps 4 through 6 to the path  */
/*       name created in steps 1 and 2.                              */
/*                                                                   */
/*   If the canonical name has a path, it is destined for an end     */
/*   user, so we should not radically transform it like we do for    */
/*   files in the spool directory.  Thus, if the canonical name has  */
/*   a path, mung the canonical file name as follows:                */
/*                                                                   */
/*   1 - skip any path from the canonical name                       */
/*                                                                   */
/*   2 - copy up to 8 character from the canonical name converting . */
/*       to _ and uppercase to lowercase.                            */
/*                                                                   */
/*   3 - if the name was longer than 8 character copy a . to the     */
/*       host name and then copy the up to three characters from     */
/*       the tail of the canonical name to the host name.            */
/*                                                                   */
/*   Note that this set of rules will cause a collision with names   */
/*   that only differ in case, but leaves the name in a recongizable */
/*   format for the user.                                            */
/*-------------------------------------------------------------------*/

void importpath(char *local, char const *canon, char const *remote)
{
   char *s, *out;
   size_t charsetsize;     /* Number of allowed characters in
                              MS-DOS file names                   */

   out = local;

/*--------------------------------------------------------------------*/
/*                       Verify our parameters                        */
/*--------------------------------------------------------------------*/

   if ( local == NULL )
      panic();

   if ( canon == NULL )
      panic();

/*--------------------------------------------------------------------*/
/*                      Define our character set                      */
/*--------------------------------------------------------------------*/

    if ( E_charset == NULL )
       E_charset = DOSCHARS;

    charsetsize = strlen( E_charset );

/*--------------------------------------------------------------------*/
/*                 Determine if spool file directory                  */
/*--------------------------------------------------------------------*/

   if ((s = strrchr(canon, '/')) == (char *)NULL)
   {                          /* File for spooling directory, use
                                 internal character set to avoid
                                 collisons                           */
      static size_t range =  UNIX_END_C - UNIX_START_C + 1;
                              /* Determine unique number characters in
                                 the UNIX file names we are mapping  */

      size_t remlen = min(HOSTLEN, strlen(remote));
                              /* Length of the remote name passed
                                 in, shortened below to number of
                                 characters matched in name          */
      size_t nodelen = min(HOSTLEN, strlen(E_nodename));
                              /* Length of the local host name,
                                 shortened below to number of
                                 characters matched in name          */
      size_t subscript = 0;   /* Value of UNIX character to be
                                 converted to MS-DOS character set   */
      char *next        = local + remlen;
      char tempname[FILENAME_MAX];
      unsigned char number[MAX_DIGITS];
                              /* Arbitary length number, for base
                                 conversions                        */

      boolean longname;

      printmsg(4,"importpath: Checking File system for spool directory %s",
                  E_spooldir );
      longname = advancedFS( E_spooldir ) && bflag[B_LONGNAME];

/*--------------------------------------------------------------------*/
/*                    Verify we have a remote name                    */
/*--------------------------------------------------------------------*/

      if ( remote == NULL )
         panic();

/*--------------------------------------------------------------------*/
/*    Put the host name (up to six characters) at the beginning of    */
/*    the MS-DOS file name as a sub-directory name.                   */
/*--------------------------------------------------------------------*/

      strncpy(local, remote, remlen);
      *next++ = '/';          /* Add in the sub-directory seperator  */
      s = (char *) canon;     /* Get the beginnging of the UNIX name */

/*--------------------------------------------------------------------*/
/*    Files in the spooling directory generally start with "D.",      */
/*    "C.", or "X."; strip off any upper case letter followed by a    */
/*    period into its own directory.                                  */