Changeset 09220c8 in rtems


Ignore:
Timestamp:
Dec 14, 2014, 11:30:23 PM (5 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
4.11, master
Children:
7cdabc49
Parents:
1ae7baf
git-author:
Joel Sherrill <joel.sherrill@…> (12/14/14 23:30:23)
git-committer:
Joel Sherrill <joel.sherrill@…> (01/04/15 19:44:57)
Message:

untar.c: Coverity ID 26151 and reformat

The Coverity issue was an ignored return value from a read()
in a loop which should have been a seek() since the data
read was ignored.

The file itself needed reformatting to conform to RTEMS style.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • cpukit/libmisc/untar/untar.c

    r1ae7baf r09220c8  
    11/**
    22 * @file
    3  *
     3
    44 * @brief Untar an Image
    55 * @ingroup libmisc_untar_img Untar Image
    6  *
     6
    77 * FIXME:
    88 *   1. Symbolic links are not created.
    99 *   2. Untar_FromMemory uses FILE *fp.
    1010 *   3. How to determine end of archive?
    11  *
     11
    1212 */
    1313
    1414/*
    1515 *  Written by: Jake Janovetz <janovetz@tempest.ece.uiuc.edu>
    16  *
     16
    1717 *  The license and distribution terms for this file may be
    1818 *  found in the file LICENSE in this distribution or at
     
    3535
    3636
    37 /**************************************************************************
     37/*
    3838 * TAR file format:
    39  *
     39
    4040 *   Offset   Length   Contents
    4141 *     0    100 bytes  File name ('\0' terminated, 99 maxmum length)
     
    6464 *   for(i = 0; i < 512; i++)
    6565 *       sum += 0xFF & header[i];
    66  *************************************************************************/
     66 */
    6767
    6868#define MAX_NAME_FIELD_SIZE      99
    6969
    70 /**************************************************************************
     70/*
    7171 * This converts octal ASCII number representations into an
    7272 * unsigned long.  Only support 32-bit numbers for now.
    73  *************************************************************************/
     73 */
    7474unsigned long
    7575_rtems_octal2ulong(
     
    7878)
    7979{
    80    size_t        i;
    81    unsigned long num;
    82 
    83    num = 0;
    84    for (i=0; i < len; i++)
    85    {
    86       if ((octascii[i] < '0') || (octascii[i] > '9'))
    87       {
    88          continue;
    89       }
    90       num  = num * 8 + ((unsigned long)(octascii[i] - '0'));
    91    }
    92    return(num);
     80  size_t        i;
     81  unsigned long num;
     82
     83  num = 0;
     84  for (i=0; i < len; i++) {
     85    if ((octascii[i] < '0') || (octascii[i] > '9')) {
     86      continue;
     87    }
     88    num  = num * 8 + ((unsigned long)(octascii[i] - '0'));
     89  }
     90  return(num);
    9391}
    9492
    95 
    96 /**************************************************************************
    97  * Function: Untar_FromMemory                                             *
    98  **************************************************************************
    99  * Description:                                                           *
    100  *                                                                        *
    101  *    This is a simple subroutine used to rip links, directories, and     *
    102  *    files out of a block of memory.                                     *
    103  *                                                                        *
    104  *                                                                        *
    105  * Inputs:                                                                *
    106  *                                                                        *
    107  *    void *  tar_buf    - Pointer to TAR buffer.                         *
    108  *    size_t  size       - Length of TAR buffer.                          *
    109  *                                                                        *
    110  *                                                                        *
    111  * Output:                                                                *
    112  *                                                                        *
    113  *    int - UNTAR_SUCCESSFUL (0)    on successful completion.             *
    114  *          UNTAR_INVALID_CHECKSUM  for an invalid header checksum.       *
    115  *          UNTAR_INVALID_HEADER    for an invalid header.                *
    116  *                                                                        *
    117  **************************************************************************/
     93/*
     94 * Function: Untar_FromMemory
     95 *
     96 * Description:
     97 *
     98 *    This is a simple subroutine used to rip links, directories, and
     99 *    files out of a block of memory.
     100 *
     101 *
     102 * Inputs:
     103 *
     104 *    void *  tar_buf    - Pointer to TAR buffer.
     105 *    size_t  size       - Length of TAR buffer.
     106 *
     107 *
     108 * Output:
     109 *
     110 *    int - UNTAR_SUCCESSFUL (0)    on successful completion.
     111 *          UNTAR_INVALID_CHECKSUM  for an invalid header checksum.
     112 *          UNTAR_INVALID_HEADER    for an invalid header.
     113 *
     114 */
    118115int
    119116Untar_FromMemory(
     
    122119)
    123120{
    124    FILE           *fp;
    125    const char     *tar_ptr = (const char *)tar_buf;
    126    const char     *bufr;
    127    size_t         n;
    128    char           fname[100];
    129    char           linkname[100];
    130    int            sum;
    131    int            hdr_chksum;
    132    int            retval;
    133    unsigned long  ptr;
    134    unsigned long  i;
    135    unsigned long  nblocks;
    136    unsigned long  file_size;
    137    unsigned char  linkflag;
    138 
    139 
    140    ptr = 0;
    141    while (1)
    142    {
    143       if (ptr + 512 > size)
    144       {
    145          retval = UNTAR_SUCCESSFUL;
    146          break;
     121  FILE           *fp;
     122  const char     *tar_ptr = (const char *)tar_buf;
     123  const char     *bufr;
     124  size_t         n;
     125  char           fname[100];
     126  char           linkname[100];
     127  int            sum;
     128  int            hdr_chksum;
     129  int            retval;
     130  unsigned long  ptr;
     131  unsigned long  i;
     132  unsigned long  nblocks;
     133  unsigned long  file_size;
     134  unsigned char  linkflag;
     135
     136  ptr = 0;
     137  while (1) {
     138    if (ptr + 512 > size) {
     139      retval = UNTAR_SUCCESSFUL;
     140      break;
     141    }
     142
     143    /* Read the header */
     144    bufr = &tar_ptr[ptr];
     145    ptr += 512;
     146    if (strncmp(&bufr[257], "ustar", 5)) {
     147      retval = UNTAR_SUCCESSFUL;
     148      break;
     149    }
     150
     151    strncpy(fname, bufr, MAX_NAME_FIELD_SIZE);
     152    fname[MAX_NAME_FIELD_SIZE] = '\0';
     153
     154    linkflag   = bufr[156];
     155    file_size  = _rtems_octal2ulong(&bufr[124], 12);
     156
     157    /*
     158     * Compute the TAR checksum and check with the value in
     159     * the archive.  The checksum is computed over the entire
     160     * header, but the checksum field is substituted with blanks.
     161     */
     162    hdr_chksum = _rtems_octal2ulong(&bufr[148], 8);
     163    sum = _rtems_tar_header_checksum(bufr);
     164
     165    if (sum != hdr_chksum) {
     166      retval = UNTAR_INVALID_CHECKSUM;
     167      break;
     168    }
     169
     170    /*
     171     * We've decoded the header, now figure out what it contains and
     172     * do something with it.
     173     */
     174    if (linkflag == SYMTYPE) {
     175      strncpy(linkname, &bufr[157], MAX_NAME_FIELD_SIZE);
     176      linkname[MAX_NAME_FIELD_SIZE] = '\0';
     177      symlink(linkname, fname);
     178    } else if (linkflag == REGTYPE) {
     179      nblocks = (((file_size) + 511) & ~511) / 512;
     180      if ((fp = fopen(fname, "w")) == NULL) {
     181        printk("Untar: failed to create file %s\n", fname);
     182        ptr += 512 * nblocks;
     183      } else {
     184        unsigned long sizeToGo = file_size;
     185        size_t len;
     186
     187        /*
     188         * Read out the data.  There are nblocks of data where nblocks
     189         * is the file_size rounded to the nearest 512-byte boundary.
     190         */
     191        for (i=0; i<nblocks; i++) {
     192          len = ((sizeToGo < 512L)?(sizeToGo):(512L));
     193          n = fwrite(&tar_ptr[ptr], 1, len, fp);
     194          if (n != len) {
     195            printk("untar: Error during write\n");
     196            retval  = UNTAR_FAIL;
     197            break;
     198          }
     199          ptr += 512;
     200          sizeToGo -= n;
     201        }
     202        fclose(fp);
    147203      }
    148 
    149       /* Read the header */
    150       bufr = &tar_ptr[ptr];
    151       ptr += 512;
    152       if (strncmp(&bufr[257], "ustar", 5))
    153       {
    154          retval = UNTAR_SUCCESSFUL;
    155          break;
     204    } else if (linkflag == DIRTYPE) {
     205      if ( mkdir(fname, S_IRWXU | S_IRWXG | S_IRWXO) != 0 ) {
     206        printk("Untar: failed to create directory %s\n", fname);
     207        retval = UNTAR_FAIL;
     208        break;
    156209      }
    157 
    158       strncpy(fname, bufr, MAX_NAME_FIELD_SIZE);
    159       fname[MAX_NAME_FIELD_SIZE] = '\0';
    160 
    161       linkflag   = bufr[156];
    162       file_size  = _rtems_octal2ulong(&bufr[124], 12);
    163 
    164       /******************************************************************
    165        * Compute the TAR checksum and check with the value in
    166        * the archive.  The checksum is computed over the entire
    167        * header, but the checksum field is substituted with blanks.
    168        ******************************************************************/
    169       hdr_chksum = _rtems_octal2ulong(&bufr[148], 8);
    170       sum = _rtems_tar_header_checksum(bufr);
    171 
    172       if (sum != hdr_chksum)
    173       {
    174          retval = UNTAR_INVALID_CHECKSUM;
    175          break;
    176       }
    177 
    178 
    179       /******************************************************************
    180        * We've decoded the header, now figure out what it contains and
    181        * do something with it.
    182        *****************************************************************/
    183       if (linkflag == SYMTYPE)
    184       {
    185          strncpy(linkname, &bufr[157], MAX_NAME_FIELD_SIZE);
    186          linkname[MAX_NAME_FIELD_SIZE] = '\0';
    187          symlink(linkname, fname);
    188       }
    189       else if (linkflag == REGTYPE)
    190       {
    191          nblocks = (((file_size) + 511) & ~511) / 512;
    192          if ((fp = fopen(fname, "w")) == NULL)
    193          {
    194             printk("Untar: failed to create file %s\n", fname);
    195             ptr += 512 * nblocks;
    196          }
    197          else
    198          {
    199             unsigned long sizeToGo = file_size;
    200             size_t len;
    201 
    202             /***************************************************************
    203              * Read out the data.  There are nblocks of data where nblocks
    204              * is the file_size rounded to the nearest 512-byte boundary.
    205              **************************************************************/
    206             for (i=0; i<nblocks; i++)
    207             {
    208                len = ((sizeToGo < 512L)?(sizeToGo):(512L));
    209                n = fwrite(&tar_ptr[ptr], 1, len, fp);
    210                if (n != len)
    211                {
    212                   printk("untar: Error during write\n");
    213                   retval  = UNTAR_FAIL;
    214                   break;
    215                }
    216                ptr += 512;
    217                sizeToGo -= n;
    218             }
    219             fclose(fp);
    220          }
    221       }
    222       else if (linkflag == DIRTYPE)
    223       {
    224          if ( mkdir(fname, S_IRWXU | S_IRWXG | S_IRWXO) != 0 ) {
    225            printk("Untar: failed to create directory %s\n", fname);
    226            retval = UNTAR_FAIL;
    227            break;
    228          }
    229       }
    230    }
    231 
    232    return(retval);
     210    }
     211  }
     212
     213  return(retval);
    233214}
    234215
    235 
    236 /**************************************************************************
    237  * Function: Untar_FromFile                                               *
    238  **************************************************************************
    239  * Description:                                                           *
    240  *                                                                        *
    241  *    This is a simple subroutine used to rip links, directories, and     *
    242  *    files out of a TAR file.                                            *
    243  *                                                                        *
    244  *                                                                        *
    245  * Inputs:                                                                *
    246  *                                                                        *
    247  *    const char *tar_name   - TAR filename.                              *
    248  *                                                                        *
    249  *                                                                        *
    250  * Output:                                                                *
    251  *                                                                        *
    252  *    int - UNTAR_SUCCESSFUL (0)    on successful completion.             *
    253  *          UNTAR_INVALID_CHECKSUM  for an invalid header checksum.       *
    254  *          UNTAR_INVALID_HEADER    for an invalid header.                *
    255  *                                                                        *
    256  **************************************************************************
    257  * Change History:                                                        *
    258  *  12/30/1998 - Creation (JWJ)                                           *
    259  *************************************************************************/
     216/*
     217 * Function: Untar_FromFile
     218 *
     219 * Description:
     220 *
     221 *    This is a simple subroutine used to rip links, directories, and
     222 *    files out of a TAR file.
     223 *
     224 * Inputs:
     225 *
     226 *    const char *tar_name   - TAR filename.
     227 *
     228 * Output:
     229 *
     230 *    int - UNTAR_SUCCESSFUL (0)    on successful completion.
     231 *          UNTAR_INVALID_CHECKSUM  for an invalid header checksum.
     232 *          UNTAR_INVALID_HEADER    for an invalid header.
     233 */
    260234int
    261235Untar_FromFile(
     
    263237)
    264238{
    265    int            fd;
    266    char           *bufr;
    267    ssize_t        n;
    268    char           fname[100];
    269    char           linkname[100];
    270    int            sum;
    271    int            hdr_chksum;
    272    int            retval;
    273    unsigned long  i;
    274    unsigned long  nblocks;
    275    unsigned long  size;
    276    unsigned char  linkflag;
    277 
    278    retval = UNTAR_SUCCESSFUL;
    279 
    280    if ((fd = open(tar_name, O_RDONLY)) < 0) {
    281        return UNTAR_FAIL;
    282    }
    283 
    284    bufr = (char *)malloc(512);
    285    if (bufr == NULL) {
    286       close(fd);
    287       return(UNTAR_FAIL);
    288    }
    289 
    290    while (1)
    291    {
    292       /* Read the header */
    293       /* If the header read fails, we just consider it the end
    294          of the tarfile. */
    295       if ((n = read(fd, bufr, 512)) != 512)
    296       {
    297          break;
     239  int            fd;
     240  char           *bufr;
     241  ssize_t        n;
     242  char           fname[100];
     243  char           linkname[100];
     244  int            sum;
     245  int            hdr_chksum;
     246  int            retval;
     247  unsigned long  i;
     248  unsigned long  nblocks;
     249  unsigned long  size;
     250  unsigned char  linkflag;
     251
     252  retval = UNTAR_SUCCESSFUL;
     253
     254  if ((fd = open(tar_name, O_RDONLY)) < 0) {
     255    return UNTAR_FAIL;
     256  }
     257
     258  bufr = (char *)malloc(512);
     259  if (bufr == NULL) {
     260    close(fd);
     261    return(UNTAR_FAIL);
     262  }
     263
     264  while (1) {
     265    /* Read the header */
     266    /* If the header read fails, we just consider it the end of the tarfile. */
     267    if ((n = read(fd, bufr, 512)) != 512) {
     268      break;
     269    }
     270
     271    if (strncmp(&bufr[257], "ustar", 5)) {
     272      break;
     273    }
     274
     275    strncpy(fname, bufr, MAX_NAME_FIELD_SIZE);
     276    fname[MAX_NAME_FIELD_SIZE] = '\0';
     277
     278    linkflag   = bufr[156];
     279    size       = _rtems_octal2ulong(&bufr[124], 12);
     280
     281    /*
     282     * Compute the TAR checksum and check with the value in
     283     * the archive.  The checksum is computed over the entire
     284     * header, but the checksum field is substituted with blanks.
     285     */
     286    hdr_chksum = _rtems_octal2ulong(&bufr[148], 8);
     287    sum = _rtems_tar_header_checksum(bufr);
     288
     289    if (sum != hdr_chksum) {
     290      retval = UNTAR_INVALID_CHECKSUM;
     291      break;
     292    }
     293
     294    /*
     295     * We've decoded the header, now figure out what it contains and
     296     * do something with it.
     297     */
     298    if (linkflag == SYMTYPE) {
     299      strncpy(linkname, &bufr[157], MAX_NAME_FIELD_SIZE);
     300      linkname[MAX_NAME_FIELD_SIZE] = '\0';
     301      symlink(linkname,fname);
     302    } else if (linkflag == REGTYPE) {
     303      int out_fd;
     304
     305      /*
     306       * Read out the data.  There are nblocks of data where nblocks
     307       * is the size rounded to the nearest 512-byte boundary.
     308       */
     309      nblocks = (((size) + 511) & ~511) / 512;
     310
     311      if ((out_fd = creat(fname, 0644)) == -1) {
     312        (void) lseek(fd, SEEK_CUR, 512 * nblocks);
     313      } else {
     314        for (i=0; i<nblocks; i++) {
     315          n = read(fd, bufr, 512);
     316          n = MIN(n, size - i*512);
     317          (void) write(out_fd, bufr, n);
     318        }
     319        close(out_fd);
    298320      }
    299 
    300       if (strncmp(&bufr[257], "ustar", 5))
    301       {
    302          break;
    303       }
    304 
    305       strncpy(fname, bufr, MAX_NAME_FIELD_SIZE);
    306       fname[MAX_NAME_FIELD_SIZE] = '\0';
    307 
    308       linkflag   = bufr[156];
    309       size       = _rtems_octal2ulong(&bufr[124], 12);
    310 
    311       /******************************************************************
    312        * Compute the TAR checksum and check with the value in
    313        * the archive.  The checksum is computed over the entire
    314        * header, but the checksum field is substituted with blanks.
    315        ******************************************************************/
    316       hdr_chksum = _rtems_octal2ulong(&bufr[148], 8);
    317       sum = _rtems_tar_header_checksum(bufr);
    318 
    319       if (sum != hdr_chksum)
    320       {
    321          retval = UNTAR_INVALID_CHECKSUM;
    322          break;
    323       }
    324 
    325       /******************************************************************
    326        * We've decoded the header, now figure out what it contains and
    327        * do something with it.
    328        *****************************************************************/
    329       if (linkflag == SYMTYPE)
    330       {
    331          strncpy(linkname, &bufr[157], MAX_NAME_FIELD_SIZE);
    332          linkname[MAX_NAME_FIELD_SIZE] = '\0';
    333          symlink(linkname,fname);
    334       }
    335       else if (linkflag == REGTYPE)
    336       {
    337          int out_fd;
    338 
    339          /******************************************************************
    340           * Read out the data.  There are nblocks of data where nblocks
    341           * is the size rounded to the nearest 512-byte boundary.
    342           *****************************************************************/
    343          nblocks = (((size) + 511) & ~511) / 512;
    344 
    345          if ((out_fd = creat(fname, 0644)) == -1)
    346          {
    347             for (i=0; i<nblocks; i++)
    348             {
    349                n = read(fd, bufr, 512);
    350             }
    351          }
    352          else
    353          {
    354             for (i=0; i<nblocks; i++)
    355             {
    356                n = read(fd, bufr, 512);
    357                n = MIN(n, size - i*512);
    358                write(out_fd, bufr, n);
    359             }
    360             close(out_fd);
    361          }
    362       }
    363       else if (linkflag == DIRTYPE)
    364       {
    365          mkdir(fname, S_IRWXU | S_IRWXG | S_IRWXO);
    366       }
    367    }
    368    free(bufr);
    369    close(fd);
    370 
    371    return(retval);
     321    } else if (linkflag == DIRTYPE) {
     322      (void) mkdir(fname, S_IRWXU | S_IRWXG | S_IRWXO);
     323    }
     324  }
     325  free(bufr);
     326  close(fd);
     327
     328  return(retval);
    372329}
    373330
    374 /************************************************************************
     331/*
    375332 * Compute the TAR checksum and check with the value in
    376333 * the archive.  The checksum is computed over the entire
    377334 * header, but the checksum field is substituted with blanks.
    378  ************************************************************************/
     335 */
    379336int
    380337_rtems_tar_header_checksum(
     
    382339)
    383340{
    384    int  i, sum;
    385 
    386    sum = 0;
    387    for (i=0; i<512; i++)
    388    {
    389       if ((i >= 148) && (i < 156))
    390          sum += 0xff & ' ';
    391       else
    392          sum += 0xff & bufr[i];
    393    }
    394    return(sum);
     341  int  i, sum;
     342
     343  sum = 0;
     344  for (i=0; i<512; i++) {
     345    if ((i >= 148) && (i < 156))
     346      sum += 0xff & ' ';
     347    else
     348     sum += 0xff & bufr[i];
     349  }
     350  return(sum);
    395351}
Note: See TracChangeset for help on using the changeset viewer.