home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / os2 / gtak / source / libx / dosname.c next >
Encoding:
C/C++ Source or Header  |  1993-01-16  |  5.4 KB  |  245 lines
  1. /*****************************************************************************
  2.  * $Id: dosname.c,v 1.4 1993/01/16 17:05:58 ak Exp $
  3.  *****************************************************************************
  4.  * Unix/HPFS filename translation for FAT file systems
  5.  * Author: Kai Uwe Rommel
  6.  *
  7.  * $Log: dosname.c,v $
  8.  * Revision 1.4  1993/01/16  17:05:58  ak
  9.  * *** empty log message ***
  10.  *
  11.  * Revision 1.3  1992/10/12  12:16:32  ak
  12.  * *** empty log message ***
  13.  *
  14.  * Revision 1.2  1992/09/21  15:20:30  ak
  15.  * *** empty log message ***
  16.  *
  17.  * Revision 1.1  1992/09/14  12:24:08  ak
  18.  * Initial revision
  19.  *
  20.  *****************************************************************************/
  21.  
  22. #if defined(OS2) && OS2 >= 2
  23.  
  24. static char *rcsid = "$Id: dosname.c,v 1.4 1993/01/16 17:05:58 ak Exp $";
  25.  
  26.  
  27.  
  28. #include <stdlib.h>
  29. #include <string.h>
  30. #include <ctype.h>
  31.  
  32. #define INCL_DOSFILEMGR
  33. #define INCL_DOSERRORS
  34. #include <os2.h>
  35.  
  36.  
  37. void ChangeNameForFAT(char *name)
  38. {
  39.   char *src, *dst, *next, *ptr, *dot, *start;
  40.   static char invalid[] = ":;,=+\"[]<>| \t";
  41.  
  42.   if ( isalpha(name[0]) && (name[1] == ':') )
  43.     start = name + 2;
  44.   else
  45.     start = name;
  46.  
  47.   src = dst = start;
  48.   if ( (*src == '/') || (*src == '\\') )
  49.     src++, dst++;
  50.  
  51.   while ( *src )
  52.   {
  53.     for ( next = src; *next && (*next != '/') && (*next != '\\'); next++ );
  54.  
  55.     for ( ptr = src, dot = NULL; ptr < next; ptr++ )
  56.       if ( *ptr == '.' )
  57.       {
  58.         dot = ptr; /* remember last dot */
  59.         *ptr = '_';
  60.       }
  61.  
  62.     if ( dot == NULL )
  63.       for ( ptr = src; ptr < next; ptr++ )
  64.         if ( *ptr == '_' )
  65.           dot = ptr; /* remember last _ as if it were a dot */
  66.  
  67.     if ( dot && (dot > src) &&
  68.          ((next - dot <= 4) ||
  69.           ((next - src > 8) && (dot - src > 3))) )
  70.     {
  71.       if ( dot )
  72.         *dot = '.';
  73.  
  74.       for ( ptr = src; (ptr < dot) && ((ptr - src) < 8); ptr++ )
  75.         *dst++ = *ptr;
  76.  
  77.       for ( ptr = dot; (ptr < next) && ((ptr - dot) < 4); ptr++ )
  78.         *dst++ = *ptr;
  79.     }
  80.     else
  81.     {
  82.       if ( dot && (next - src == 1) )
  83.         *dot = '.';           /* special case: "." as a path component */
  84.  
  85.       for ( ptr = src; (ptr < next) && ((ptr - src) < 8); ptr++ )
  86.         *dst++ = *ptr;
  87.     }
  88.  
  89.     *dst++ = *next; /* either '/' or 0 */
  90.  
  91.     if ( *next )
  92.     {
  93.       src = next + 1;
  94.  
  95.       if ( *src == 0 ) /* handle trailing '/' on dirs ! */
  96.         *dst = 0;
  97.     }
  98.     else
  99.       break;
  100.   }
  101.  
  102.   for ( src = start; *src != 0; ++src )
  103.     if ( strchr(invalid, *src) != NULL )
  104.         *src = '_';
  105. }
  106.  
  107.  
  108. int IsFileNameValid(char *name)
  109. {
  110.   HFILE hf;
  111.   ULONG uAction;
  112.  
  113.   switch( DosOpen(name, &hf, &uAction, 0, 0, FILE_OPEN,
  114.                   OPEN_ACCESS_READONLY | OPEN_SHARE_DENYNONE, 0) )
  115.   {
  116.   case ERROR_INVALID_NAME:
  117.   case ERROR_FILENAME_EXCED_RANGE:
  118.     return FALSE;
  119.   case NO_ERROR:
  120.     DosClose(hf);
  121.   default:
  122.     return TRUE;
  123.   }
  124. }
  125.  
  126.  
  127. typedef struct
  128. {
  129.   ULONG cbList;               /* length of value + 22 */
  130.   ULONG oNext;
  131.   BYTE fEA;                   /* 0 */
  132.   BYTE cbName;                /* length of ".LONGNAME" = 9 */
  133.   USHORT cbValue;             /* length of value + 4 */
  134.   BYTE szName[10];            /* ".LONGNAME" */
  135.   USHORT eaType;              /* 0xFFFD for length-preceded ASCII */
  136.   USHORT eaSize;              /* length of value */
  137.   BYTE szValue[CCHMAXPATH];
  138. }
  139. FEALST;
  140.  
  141. typedef struct
  142. {
  143.   ULONG cbList;
  144.   ULONG oNext;
  145.   BYTE cbName;
  146.   BYTE szName[10];            /* ".LONGNAME" */
  147. }
  148. GEALST;
  149.  
  150.  
  151. int SetLongNameEA(char *name, char *longname)
  152. {
  153.   EAOP eaop;
  154.   FEALST fealst;
  155.  
  156.   eaop.fpFEAList = (PFEALIST) &fealst;
  157.   eaop.fpGEAList = NULL;
  158.   eaop.oError = 0;
  159.  
  160.   strcpy(fealst.szName, ".LONGNAME");
  161.   strcpy(fealst.szValue, longname);
  162.  
  163.   fealst.cbList  = sizeof(fealst) - CCHMAXPATH + strlen(fealst.szValue);
  164.   fealst.cbName  = (BYTE) strlen(fealst.szName);
  165.   fealst.cbValue = sizeof(USHORT) * 2 + strlen(fealst.szValue);
  166.  
  167.   fealst.oNext   = 0;
  168.   fealst.fEA     = 0;
  169.   fealst.eaType  = 0xFFFD;
  170.   fealst.eaSize  = strlen(fealst.szValue);
  171.  
  172.   return DosSetPathInfo(name, FIL_QUERYEASIZE, (PBYTE) &eaop, sizeof(eaop), 0);
  173. }
  174.  
  175.  
  176. char *GetLongNameEA(char *name)
  177. {
  178.   EAOP eaop;
  179.   GEALST gealst;
  180.   FEALST fealst;
  181.  
  182.   eaop.fpGEAList = (PGEALIST) &gealst;
  183.   eaop.fpFEAList = (PFEALIST) &fealst;
  184.   eaop.oError = 0;
  185.  
  186.   strcpy(gealst.szName, ".LONGNAME");
  187.   gealst.cbName  = (BYTE) strlen(gealst.szName);
  188.  
  189.   gealst.cbList  = sizeof(gealst);
  190.   fealst.cbList  = sizeof(fealst);
  191.  
  192. #if OS2 >= 2
  193.   if ( DosQueryPathInfo(name, FIL_QUERYEASFROMLIST, (PBYTE) &eaop, sizeof(eaop)) )
  194. #else
  195.   if ( DosQPathInfo(name, FIL_QUERYEASFROMLIST, (PBYTE) &eaop, sizeof(eaop)) )
  196. #endif
  197.     return NULL;
  198.  
  199.   if ( fealst.cbValue > 4 && fealst.eaType == 0xFFFD )
  200.   {
  201.     fealst.szValue[fealst.eaSize] = 0;
  202.     return fealst.szValue;
  203.   }
  204.  
  205.   return NULL;
  206. }
  207.  
  208.  
  209. char *GetLongPathEA(char *name)
  210. {
  211.   static char nbuf[CCHMAXPATH + 1];
  212.   char *comp, *next, *ea, sep;
  213.   BOOL bFound = FALSE;
  214.  
  215.   nbuf[0] = 0;
  216.   next = name;
  217.  
  218.   while ( *next )
  219.   {
  220.     comp = next;
  221.  
  222.     while ( *next != '\\' && *next != '/' && *next != 0 )
  223.       next++;
  224.  
  225.     sep = *next;
  226.     *next = 0;
  227.  
  228.     ea = GetLongNameEA(name);
  229.     strcat(nbuf, ea ? ea : comp);
  230.     bFound = bFound || (ea != NULL);
  231.  
  232.     *next = sep;
  233.  
  234.     if ( *next )
  235.     {
  236.       strcat(nbuf, "\\");
  237.       next++;
  238.     }
  239.   }
  240.  
  241.   return nbuf[0] && bFound ? nbuf : NULL;
  242. }
  243.  
  244. #endif
  245.