home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-385-Vol-1of3.iso / t / tel2305s.zip / ENGINE / PCUTIL.C < prev    next >
C/C++ Source or Header  |  1992-02-22  |  12KB  |  443 lines
  1. /*  PCUTIL.C
  2. *   Utilities for the network library that are PC specific
  3. ****************************************************************************
  4. *                                                                          *
  5. *      part of:                                                            *
  6. *      TCP/UDP/ICMP/IP Network kernel for NCSA Telnet                      *
  7. *      by Tim Krauskopf                                                    *
  8. *                                                                          *
  9. *      National Center for Supercomputing Applications                     *
  10. *      152 Computing Applications Building                                 *
  11. *      605 E. Springfield Ave.                                             *
  12. *      Champaign, IL  61820                                                *
  13. *                                                                          *
  14. ****************************************************************************
  15. */
  16.  
  17. /*
  18. *    Includes
  19. */
  20. #ifdef __TURBOC__
  21. #include "turboc.h"
  22. #endif
  23. #include <stdio.h>
  24. #include <stdlib.h>
  25. #include <ctype.h>
  26. #include <string.h>
  27. #ifdef MSC
  28. #ifdef __TURBOC__
  29. #include <alloc.h>
  30. #include <dir.h>
  31. #else
  32. #include <malloc.h>
  33. #include <direct.h>
  34. #include <dos.h>
  35. #endif
  36. #endif
  37. #include "whatami.h"
  38. #include "externs.h"
  39.  
  40. static char lookcolor(char *);
  41.  
  42. /**********************************************************************/
  43. /*
  44. *   Find directory name -- return a code that indicates whether the
  45. *   directory exists or not.
  46. *   0 = dir name ok
  47. *   -1 = error
  48. *   > 0 = dos error code, no dir by this name
  49. *
  50. *   Accept certain unix conventions, like '/' for separator
  51. *
  52. *   Also, append a '\' to the name before returning
  53. * 
  54. *  Note:  There must be enough room in the string to append the '\'
  55. */
  56. struct dosdta {
  57.     char junk[21];
  58.     char att;
  59.     int time,date;
  60.     long int size;
  61.     char name[13];
  62. };
  63.  
  64. extern struct dosdta *dtaptr;    /* declared in ncsaio.asm */
  65.  
  66. #ifndef NET14
  67. int direxist(char dirname[])
  68. {
  69.     int i,ret;
  70.     char *p;
  71.  
  72.     if(!strcmp(dirname,".") || !dirname[0]) {
  73.         dirname[0]='\0';
  74.         return(0);
  75.       }
  76.     if(!strcmp(dirname,"\\"))
  77.         return(0);
  78.     p=dirname;
  79.     while(*p) {
  80.         switch(*p) {
  81.             case '*':
  82.             case '?':
  83.                 return(-1);
  84.  
  85.             case '/':
  86.                 *p='\\';
  87.                 break;
  88.           }
  89.         p++;
  90.       }
  91. /*
  92. *  n_findfirst  will return normal files AND directories
  93. *  must check attribute to see if it is really a directory
  94. */
  95.     ret=n_findfirst(dirname,0x10);        /* find name */
  96.  
  97.     if(ret)
  98.         return(ret);
  99.     if(!(dtaptr->att&0x10))
  100.         return(-2);                            /* is a normal file */
  101.     i=strlen(dirname);
  102.     dirname[i]='\\';                        /* extend with '\' */
  103.     dirname[++i]='\0';
  104.     return(0);
  105. }
  106.  
  107. /**********************************************************************/
  108. /* firstname
  109. *  find the first name in the given directory which matches the wildcard
  110. *  specification
  111. *
  112. *  expand '*' (unix) to '*.*' (dos)
  113. */
  114. char savepath[_MAX_DIR+_MAX_FNAME+_MAX_EXT+30]; /* allocate enough room for the pathname, filename, & extension, plus a little bit of slush */
  115. int rootlen;
  116.  
  117. char *firstname(char path[],int type)
  118. {
  119.     int i,len;
  120.     char *p,*q;
  121.  
  122.     if(!*path)
  123.         return(NULL);
  124.  
  125.     len=strlen(path);
  126.     i=0;
  127.     rootlen=0;
  128.     q=savepath;
  129.     p=path;
  130.     while(*q=*p) {                /* basic string copy with extras */
  131.         if(*p=='\\')
  132.             rootlen=i+1;            /* rootlen = position of last \ */
  133.         p++;
  134.         q++;
  135.         i++;
  136.       }
  137.     if(savepath[len-1]=='*' && rootlen==len-1) {
  138.         savepath[len++]='.';
  139.         savepath[len++]='*';
  140.         savepath[len++]='\0';
  141.       }
  142.     switch(type) {
  143.         case 1:
  144.             if(n_findfirst(savepath,0x10))
  145.                 return(NULL);
  146.              break;
  147.  
  148.         default: 
  149.             if(n_findfirst(savepath,0x00))
  150.                 return(NULL);
  151.              break;
  152.  
  153.       }
  154. /*
  155. *  copy file name, translate to lower case 
  156. */
  157.     q=&savepath[rootlen];
  158.     p=dtaptr->name;
  159.     while(*p) {
  160.         if(*p>='A' && *p<='Z')
  161.             *q++= (*p++) + (char) 32;
  162.         else
  163.             *q++=*p++;
  164.       }
  165. /*
  166. *  if it is a directory then put <DIR> after it
  167. */
  168.     if(type) {
  169.         p=&savepath[rootlen+20];
  170.         for(; q!=p; *q++=' ');        
  171.         if(dtaptr->att&0x10) {
  172.             *q++=' ';
  173.             *q++='<';
  174.             *q++='D';
  175.             *q++='I';
  176.             *q++='R';
  177.             *q++='>';
  178.           }
  179.         else {
  180.             sprintf(q,"%8ld",dtaptr->size);
  181.             return(savepath);
  182.           }    /* end else */
  183.          }        
  184.     *q='\0';
  185.     return(savepath);
  186. }
  187.  
  188. /**********************************************************************/
  189. /* nextname
  190. *  modify the path spec to contain the next file name in the
  191. *  sequence as given by DOS
  192. *
  193. *  if at the end of the sequence, return NULL
  194. */
  195. char *nextname(int type)
  196. {
  197.     char *p,*q;
  198.  
  199.     if(n_findnext())    /* check if there are any more filenames */
  200.         return(NULL);
  201.  
  202. /*
  203. *  copy file name, translate to lower case 
  204. */
  205.     q=&savepath[rootlen];
  206.     p=dtaptr->name;
  207.     while(*p) {
  208.         if(*p >='A' && *p<='Z')
  209.             *q++ = (*p++) + (char)32;
  210.         else
  211.             *q++=*p++;
  212.       }
  213. /*
  214. * if it is a directory, then put <DIR> after it
  215. */
  216.     if(type) {
  217.         p=&savepath[rootlen+20];
  218.         for(; q!=p; *q++=' ');        
  219.         if(dtaptr->att&0x10) {
  220.             *q++=' ';
  221.             *q++='<';
  222.             *q++='D';
  223.             *q++='I';
  224.             *q++='R';
  225.             *q++='>';
  226.           }
  227.         else {
  228.             sprintf(q,"%8ld",dtaptr->size);
  229.             return(savepath);
  230.           }    /* end else */
  231.          }        
  232.     *q='\0';
  233.     return(savepath);
  234. }
  235. /**********************************************************************/
  236. /*  getdrive
  237. *   get the current disk drive
  238. */
  239. void getdrive(unsigned int *d)
  240. {
  241. #ifdef __TURBOC__
  242.     *d=(unsigned) getdisk();
  243. #else
  244.     _dos_getdrive(d);
  245. #endif
  246. };
  247.  
  248. void setdrive(unsigned int d)
  249. {
  250.     unsigned temp;
  251. #ifdef __TURBOC__
  252.     setdisk((int) d);
  253. #else
  254.     _dos_setdrive(d, &temp);
  255. #endif
  256. };
  257.  
  258. /**********************************************************************/
  259. /*  dopwd
  260. *   get the current directory, including disk drive letter
  261. */
  262. void dopwd(char *p,int l)
  263. {
  264.     getcwd(p,l);                /* get dir */
  265. }
  266.  
  267. /**********************************************************************
  268. *    Function    :    chgdir
  269. *    Purpose    :    change to a different drive and directory
  270. *    Parameters    :
  271. *        file_name - handle of the name of the directory to change to 
  272. *    Returns    :    0 for success, 1 for error
  273. *    Calls    :    various string routines
  274. *    Called by    :    ftp server
  275. **********************************************************************/
  276. int chgdir(char *file_name)
  277. {
  278.     unsigned old_drive,     /* the old drive we were in */
  279.         temp_val;           /* temporary value */
  280.     int ret_val=0,          /* the return value from the function */
  281.         new_drive;            /* the drive to change to */
  282.     char *name_ptr,            /* pointer to the file name data */
  283.         cwd[64],            /* handle of the current directory */
  284.         *current,            /* pointer to the place in the file name */
  285.         working[64];        /* handle of a space for doing things */
  286.  
  287.     name_ptr=file_name;    /* set the pointer to the file name data */
  288. #ifdef MSC
  289. #ifdef __TURBOC__
  290.     old_drive=getdisk();        /* get the old drive number */
  291. #else
  292.     _dos_getdrive(&old_drive);    /* get the old drive number */
  293. #endif
  294. #else
  295.     old_drive=getdsk();
  296. #endif
  297.     getcwd(cwd,64);        /* get the current directory */
  298.     memmove(cwd,cwd+2,strlen(cwd)+1);    /* get rid of the drive specifier */
  299.     if(*(name_ptr+1)==':') {        /* do we have a drive specified */
  300.         new_drive=toupper((int)*name_ptr)-'A';    /* get the new drive number */
  301. #ifdef MSC
  302. #ifdef __TURBOC__
  303.         setdisk(new_drive);
  304. #else
  305.         _dos_setdrive(new_drive+1,&temp_val);
  306. #endif
  307. #else
  308.         chgdsk(new_drive);
  309. #endif
  310.         name_ptr+=2;                /* increment the name pointer */
  311.         if(*name_ptr=='\0')            /* check for simple drive change */
  312.             name_ptr=NULL;
  313.       }    /* end if */
  314.     while(*name_ptr=='\\') {        /* check for changing to the root directory */
  315.         chdir("\\");                /* change to the root directory */
  316.         name_ptr++;                    /* advance the name pointer to the next character */
  317.         if(*name_ptr=='\0')            /* check for simple drive change */
  318.             name_ptr=NULL;
  319.       }    /* end if */
  320.     while(name_ptr!=NULL && ret_val!=1) {        /* continue until the end of the string or an error occurs */
  321. #ifdef MSC
  322.         current=strchr(name_ptr,(int)'\\');        /* find the first occurence of the SLASH character */
  323. #else
  324.         current=strchr(name_ptr,(char)'\\');    /* find the first occurence of the SLASH character */
  325. #endif
  326.         if(current!=NULL) {                            /* found the SLASH character */
  327.             temp_val=current-name_ptr;                    /* find out the length of the string */
  328.             movebytes(working,name_ptr,temp_val);        /* copy the string into the working buffer */
  329.             *(working+temp_val)=0;                        /* terminate the string */
  330.             name_ptr=current+1;                        /* advance to the next part of the path name */
  331.           }    /* end if */
  332.         else {                                        /* the SLASH character is not in the name */
  333.             strcpy(working,name_ptr);
  334.             name_ptr=NULL;
  335.           }    /* end else */
  336.         if(chdir(working))        /* change the directory, but look for an error also */
  337.             ret_val=1;
  338.       }    /* end while */
  339.     if(ret_val==1) {                    /* on error, reset the old drive */
  340. #ifdef MSC
  341. #ifdef __TURBOC__
  342.         setdisk(old_drive);
  343. #else
  344.         _dos_setdrive(old_drive,&temp_val);
  345. #endif
  346. #else
  347.         chgdsk(old_drive);
  348. #endif
  349.         chdir(cwd);                    /* fix the directory */
  350.       }    /* end if */
  351.     return(ret_val);                /* return the retuen value */
  352. }    /* end chgdir() */
  353. #endif
  354.  
  355. /**********************************************************************/
  356. /*  Scolorset
  357. *  setup the color value from the config file string
  358. */
  359. void Scolorset(char *thecolor,char *st)
  360. {
  361.     *thecolor=lookcolor(st);
  362. }
  363.  
  364. /**********************************************************************/
  365. /* lookcolor
  366. *  search a list for the given color name
  367. */
  368. static char *colist[]={
  369.     "black",
  370.     "blue",
  371.     "green",    
  372.     "cyan",
  373.     "red",
  374.     "magenta",
  375.     "yellow",
  376.     "white",
  377.     "BLACK",
  378.     "BLUE",
  379.     "GREEN",    
  380.     "CYAN",
  381.     "RED",
  382.     "MAGENTA",
  383.     "YELLOW",
  384.     "WHITE"    };
  385.  
  386. static char lookcolor(char *s)
  387. {
  388.     char i;
  389.  
  390.     for(i=0; i<15; i++)
  391.         if(!strcmp(colist[i],s))
  392.             return(i);
  393.     return(15);
  394. }
  395.  
  396. #ifndef NET14
  397. /**********************************************************************
  398. *  Function    :    octal_to_int
  399. *  Purpose    :    convert an octal string to an integer (like atoi())
  400. *  Parameters    :
  401. *            octal_str - the octal string to get the value of
  402. *  Returns    :    0 to indicate that the input cannot be converted to an integer
  403. *  Calls    :    none
  404. *  Called by    :    parse_str()
  405. **********************************************************************/
  406. int octal_to_int(char *octal_str)
  407. {
  408.     unsigned int return_value=0;    /* the value to return from the function */
  409.  
  410.     while((*octal_str)>='0' && (*octal_str)<='7') {
  411.         return_value*=(return_value*8);        /* bump up the value top return to the next multiple of eight */
  412.         return_value+=((*octal_str)-'0');        /* increment by the digit found */
  413.         octal_str++;
  414.       }    /* end while */
  415.     return((int)return_value);
  416. }    /* end octal_to_int() */
  417.  
  418. /**********************************************************************
  419. *  Function    :    hex_to_int
  420. *  Purpose    :    convert an hexadecimal string to an integer (like atoi())
  421. *  Parameters    :
  422. *            hex_str - the hexadecimal string to get the value of
  423. *  Returns    :    0 to indicate that the input cannot be converted to an integer
  424. *  Calls    :    none
  425. *  Called by    :    parse_str()
  426. **********************************************************************/
  427. int hex_to_int(char *hex_str)
  428. {
  429.     unsigned int return_value=0;    /* the value to return from the function */
  430.  
  431.     while(isxdigit((int)(*hex_str))) {
  432.         return_value*=(return_value*16);        /* bump up the value top return to the next multiple of sixteen */
  433.         if(isdigit((int)(*hex_str)))    /* check whether this digit is numeric or alphabetic */
  434.             return_value+=(unsigned int)((*hex_str)-'0');        /* increment by the digit found (for '0'-'9') */
  435.         else
  436.             return_value+=(unsigned int)(tolower((int)(*hex_str))-'a'+10);    /* increment by the digit found (for 'A'-'F' & 'a'-'f') */
  437.         hex_str++;
  438.       }    /* end while */
  439.     return((int)return_value);
  440. }    /* end hex_to_int() */
  441. #endif
  442.  
  443.