tstsh.c

ertfs文件系统里面既有完整ucos程序

        {
			if (geometry.dev_geometry_lbas)
			{
				do
				{
	     			prompt_user("Press Y to USE LBA formatting, N to use CHS", buf);
				}
				while ( (buf[0] != 'Y') && (buf[0] != 'N') );

		        if (buf[0] == 'N')
        		{
					geometry.dev_geometry_lbas = 0;
				}
			}

			if (geometry.dev_geometry_lbas)
			{
	           tm_printf_2("The drive is contains %ld lbas\n", geometry.dev_geometry_lbas);
    	       prompt_user("Select the number of lbas for the first partition :", working_buffer);
        	   partition_list[0]  = (dword)tc_atol(working_buffer);
	           partition_list[1]  = 0;

    	       if (partition_list[0] != geometry.dev_geometry_lbas)
        	   {
            	   tm_printf_2("There are %ld lbas remaining \n", 
	                   geometry.dev_geometry_lbas - partition_list[0]);
    	           prompt_user("Select the number of lbas for the second partition :", working_buffer);
        	       partition_list[1]  = (dword)tc_atol(working_buffer);
				   partition_list[2]  = 0;
	            }
	           if ((partition_list[0] == 0) || ((dword)(partition_list[0]+partition_list[1])  > geometry.dev_geometry_lbas))
    	       {
        	       prompt_user("Bad input press return to exit", working_buffer);
            	    return(-1);
	            }
			}
			else
			{
        		tm_printf_2("The drive contains %d cylinders\n", geometry.dev_geometry_cylinders);
        		prompt_user("Select the number of cyls for the first partition :", working_buffer);
        		partition_list[0]  = (word)tc_atoi(working_buffer);
        		partition_list[1]  = 0;

        		if (partition_list[0] != geometry.dev_geometry_cylinders)
        		{
            		tm_printf_2("There are %d cylinders remaining \n", 
                		geometry.dev_geometry_cylinders - partition_list[0]);
            		prompt_user("Select the number of cyls for the second partition :", working_buffer);
            		partition_list[1]  = (dword)tc_atol(working_buffer);
					partition_list[2]  = 0;
        		}
	           if ((partition_list[0] == 0) || ((dword)(partition_list[0]+partition_list[1])  > geometry.dev_geometry_cylinders))
    	       {
        	       prompt_user("Bad input press return to exit", working_buffer);
            	    return(-1);
	            }
			}
            if (!pc_partition_media(path, &geometry, &partition_list[0]))
            {
               prompt_user("Media partition failed press return to exit", working_buffer);
               return(-1);
            }
        }
    }

    /* Put the DOS format */
    prompt_user("Press Y to format the volume", buf);
    if (buf[0] == 'Y')
    {

        if (!pc_format_volume(path, &geometry))
        {
           prompt_user("Format voulme failed press return to exit", working_buffer);
           return(-1);
        }
    }
    return (0);
}


/* GETATTR PATH*/ 
int dogetattr(int agc, char **agv)                                    /*__fn__*/
{
byte attr;

    if (agc == 1)
    {
        if (pc_get_attributes(*agv, &attr))
        {
            tm_printf("Attributes: ");
            if (attr & ARDONLY)
                tm_printf("ARDONLY|");
            if (attr & AHIDDEN)
                tm_printf("AHIDDEN|");
            if (attr & ASYSTEM)
                tm_printf("ASYSTEM|");
            if (attr & AVOLUME)
                tm_printf("AVOLUME|");
            if (attr & ADIRENT)
                tm_printf("ADIRENT|");
            if (attr & ARCHIVE)
                tm_printf("ARCHIVE|");
            if (attr == ANORMAL)
                tm_printf("NORMAL FILE (No bits set)");
            tm_printf("\n");
            return(0);
        }
        else
        {
            tm_printf("get attributes failed\n");
            return(0);
        }
    }
    tm_printf("Usage: GETATTR D:PATH\n");
    return (0);
}

/* GETATTR PATH*/ 
int dosetattr(int agc, char **agv)                                    /*__fn__*/
{
byte attr;

    attr = 0;
    if (agc == 2)
    {
        if (!pc_get_attributes(*agv, &attr))
        {
            tm_printf("Can't get attributes\n");
            return(0);
        }

        if (tc_strcmp(*(agv+1),"RDONLY")==0)
            attr |= ARDONLY;
        else if (tc_strcmp(*(agv+1),"HIDDEN")==0)
            attr |= AHIDDEN;
        else if (tc_strcmp(*(agv+1),"SYSTEM")==0)
            attr |= ASYSTEM;
        else if (tc_strcmp(*(agv+1),"ARCHIVE")==0)
            attr |= ARCHIVE;
        else if (tc_strcmp(*(agv+1),"NORMAL")==0)
            attr =  ANORMAL;
        else
            goto usage;

        if (pc_set_attributes(*agv, attr))
            return(0);
        else
        {
            tm_printf("Set attributes failed\n");
            return(0);
        }
    }
usage:
    tm_printf("Usage: SETATTR D:PATH RDONLY|HIDDEN|SYSTEM|ARCHIVE|NORMAL\n");

    return (0);
}

BOOLEAN pc_gets(int fd, char *buf)                                     /*__fn__*/
{
int i;
char c;
int ncopied = 0;
    
    /* We use ncopied to throw away any leading/ trailing newlines */
    *buf = '\0';

    for (i = 0; i < 80; i++)
    {
        if (po_read(fd, (byte*) &c, 1) != 1)
            return(FALSE);
        if (c == '\n' || c == '\r')
        {
            if (ncopied)
                return(TRUE);
        }
        else
        {
            *buf++ = c;
            *buf = '\0';
            ncopied += 1;
        }
    }
    return(FALSE);
}

/* Return 1 if buffer starts with the string in buffer */
int compare(char *constant, char *buffer)                           /*__fn__*/
{
    if (!*constant)
        return(0);

    while (*constant && *buffer == *constant)
    {
        buffer++;
        constant++;
    }
    if (!*constant)      /* If at \0 we found a match */
        return(1);
    else
        return(0);
}

/* Long to Decimal converter */    
/* Note dest buffer must hold at least 15 bytes */
void int_tostring(long num, char *dest)                              /*__fn__*/
{
    long digit;
    char *olddest;
    char *p;
    int base;

    olddest = dest;
    
    base = 10;

    dest += 15;    
    *dest = '\0';

    /* Convert num to a string going from dest[15] backwards */    
    /* Nasty little ItoA algorith */
    do
    {
        digit = num % base;
        *(--dest) =
          (char)(digit<10 ? (char)(digit + '0') : (char)((digit-10) + 'A'));
        num = num / base;
    }
    while (num);

    /* Now put the converted string at the beginning of the buffer */
    for (p = olddest; *dest;)
        *p++ = *dest++;
    *p = '\0';
}



#if (USE_CDFS)

/* DSKOPEN PATH */ 
int cddodskop(int agc, char **agv)                                    /*__fn__*/
{
    if (agc == 1)
    {
        if (cd_dskopen(*agv))
        {
            cddoselect(agc, agv);
            return(1);
        }
        else
        {
            tm_printf_2("Can't open disk %s\n",*agv);
            return(0);
        }
    }
    tm_printf("Usage: DSKOPEN D:\n");
    return(0);
}


/* DSKCLOSE PATH */ 
int cddodskcl(int agc, char **agv)                                /*__fn__*/
{
    if (agc == 1)
    {
        cd_dskclose(*agv);
    }
    else
        tm_printf("Usage: DSKCLOSE D: \n");
    return(1);
 }

/* DSKSEL PATH */ 
int cddoselect(int agc, char **agv)                                   /*__fn__*/
{

    if (agc == 1)
    {
        if (cd_set_default_drive(*agv))
            return(1);
        else
        {
            tm_printf("?\n");
            return(0);
        }
    }
    else 
    {
         tm_printf("Usage: DSKSELECT D: \n");
         return(0);
    }
}

/* CD PATH */
int cddocwd(int agc, char **agv)                                      /*__fn__*/
{
char lbuf[255];
    if (agc == 1)
    {
        if (cd_scwd(*agv))
            return(1);
        else
            return(0);
    }
    else
    {
        lbuf[0] = '\0';
        if (cd_gcwd(lbuf))
        {
            tm_printf_2("%s\n",lbuf);
            return (1);
        }
        else
        {
            tm_printf("path error\n");
            return(0);
        }
    }
}


/* DIR PATH */
int cddols(int agc, char **agv)                                      /*__fn__*/
{
    char *dirstr;
    CD_DSTAT dirent;
    char lbuf[255];

    if (agc==1)
        strcpy(lbuf, *agv);
    else
        strcpy(lbuf, "*.*");

    if (!cd_gfirst(&dirent,lbuf))
        return(0);
    do
    {
        if (dirent.dir.file_flags & FF_DIRECTORY)
            dirstr = "<DIR>";
        else
            dirstr = "     ";

        if ((dirent.dir.len_fi == 1) && (dirent.dir.file_id[0] == 0))
        {
            dirent.dir.file_id[0] = '.';
            dirent.dir.file_id[1] = 0;
        }
        if ((dirent.dir.len_fi == 1) && (dirent.dir.file_id[0] == 1))
        {
            dirent.dir.file_id[0] = '.';
            dirent.dir.file_id[1] = '.';
            dirent.dir.file_id[2] = 0;
        }

        tm_printf_2("%-15.15s ",dirent.dir.file_id);
        tm_printf_2("%-5.5s ",  dirstr);
        tm_printf_2("%7ld ",    dirent.dir.data_len);
        tm_printf_2("%02d-",    dirent.dir.record_time.month);
        tm_printf_2("%02d-",    dirent.dir.record_time.day);
        tm_printf_2("%02d ",    dirent.dir.record_time.year);
        tm_printf_2("%02d:",    dirent.dir.record_time.hour);
        tm_printf_2("%02d:",    dirent.dir.record_time.min);
        tm_printf_2("%02d\n",   dirent.dir.record_time.sec);

    } while (cd_gnext(&dirent,lbuf));

    cd_gdone(&dirent);
    return(1);
}

/* CAT PATH */ 
int cddocat(int agc, char **agv)                                  /*__fn__*/
{
    CDFD fd;
    int n_read;
    char buff[42];
    BOOLEAN forever = TRUE;         /* use this for while(forever) to quiet anal compilers */


    if (agc == 1)
    {
        fd=cd_open(*agv);

        if (fd < 0)
        {
            tm_printf_2("Cant open %s\n", *agv);
            return(0);
        }
        else
        {
            while (forever)
            {
                n_read = cd_read(fd, (byte *)buff, 40);
                if (n_read > 0)
                {
                    buff[n_read] = '\0';
                    tm_printf_2("%s",buff);
                }
                else
                    break;
            }
            cd_close(fd);
            return(1);
        }
    }
    else
    {
        tm_printf("Usage: CAT PATH\n");
        return(0);
    }
}

#define ZERO 0
#if (ZERO)
/* READ PATH */ 
int cddoread(int agc, char **agv)                                  /*__fn__*/
{
    CDFD fd;
    word n_read;
    BOOLEAN forever = TRUE;         /* use this for while(forever) to quiet anal compilers */


    if (agc == 1)
    {
        fd=cd_open(*agv);

        if (fd < 0)
        {
            tm_printf_2("Cant open %s\n", *agv);
            return(0);
        }
        else
        {
            while (forever)
            {
                n_read = cd_read(fd, (byte *)read_buf, (word) 16384);
                if ( (n_read != 0) && (n_read <= 16384)  )
                {
                    tm_printf(".");
                }
                else
                {
                    tm_printf("\n");
                    break;
                }
            }
            cd_close(fd);
            return(1);
        }
    }
    else
    {
        tm_printf("Usage: READ PATH\n");
        return(0);
    }
}



/* COPY CDFILE DOSFILE */ 
int cddocopy(int agc, char **agv)                                  /*__fn__*/
{
    BOOLEAN is_wild = FALSE;
    CD_DSTAT dirent;
    char *p;
    char *p2;
    char *last_s;
    char tofile[255];
    char from_dir[255];
    char from_file[255];
    
    from_dir[0] = '\0';

    if (agc == 2)
    {
        
        /* See if we have a wild card */
        p = *agv;
        while (*p)
            {if (*p == '*' || *p == '?'){is_wild = TRUE; break;} p++;}
        if (is_wild)
        {
            /* Copy the source path into from dir. Remember the location just
               past the lat \ character. Later on we cat the file to it to 
               create the source file name. If there is no '\' this will all 
               be harmless */
            p = *agv;
            p2 = &from_dir[0];
            last_s = &from_dir[0];
            while (*p)
            {
                *p2++ = *p;
                if ((*p == BACKSLASH) || (*p == ':'))
                    last_s = p2;
                p++;
            }
            *last_s = '\0';
    
            if (!cd_gfirst(&dirent,*agv))
                return(FALSE);
            do
            {
                if (!(dirent.dir.file_flags & FF_DIRECTORY))
                {
                    strcpy(tofile, *(agv+1));
                    strcat(tofile, "\\");
                    strcat(tofile, dirent.dir.file_id);
                    strcpy(from_file, from_dir);
                    strcat(from_file, dirent.dir.file_id);
                    if (!copy_one_file(tofile,from_file))
                    {
                        cd_gdone(&dirent);
                        return(FALSE);
                    }
                }
            } while (cd_gnext(&dirent,*agv));
            cd_gdone(&dirent);
        }
        else
        {
            if (!copy_one_file(*(agv+1), *agv))
                return(0);
        }
    }
    else
    {
        tm_printf("Usage: COPY CDPATH OSPATH\n");
        return(0);
    }
    return(1);
}

/* READ PATH */ 
BOOLEAN copy_one_file(char *to, char *from)                             /*__fn__*/
{
    CDFD fd;
    int fi;
    word n_read;
    BOOLEAN forever = TRUE;         /* use this for while(forever) to quiet anal compilers */
    int do_dot;

    fd=cd_open(from);
    if (fd < 0)
    {
        tm_printf_2("Cant open %s\n", from);
        return(FALSE);
    }
    if ( (fi = open(to,O_WRONLY|O_BINARY|O_CREAT|O_TRUNC, S_IREAD | S_IWRITE)) < 0)        /* msc open */
    {
        tm_printf_2("Cant creat %s\n",to);
        cd_close(fd);
        return(FALSE);
    }
    tm_printf_2("%s\n", from);
    do_dot = 2;
    while (forever)
    {
        
        cd_read(fd, (byte *)read_buf, (word)32768L);
        if((n_read != 0xffff) && (n_read > 0))
        {
            if (!--do_dot)
            {
                tm_printf(".");
                do_dot = 2;
            }
            if ( (unsigned)write (fi,read_buf,n_read) != n_read)
            {
                tm_printf("\nWrite error\n");
                close(fi);
                cd_close(fd);
                return (FALSE);
            }
        }
        else
        {
            close(fi);
            cd_close(fd);
            tm_printf("\n");
            break;
        }
    }
    return(TRUE);
}

#endif // ZERO
#endif // CDFS