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