/*

 * atari partitions parsing code

 *

 * Copyright (C) 2018 Vaclav Dolezal <vdolezal@redhat.com>

 *

 * This file may be redistributed under the terms of the

 * GNU Lesser General Public License.

 *

 * Based on Linux kernel implementation and atari-fdisk

 */

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <stdint.h>

#include "partitions.h"

struct atari_part_def {

  /*

   * flags:

   * 0 (LSB): active

   * 1-6:     (reserved)

   * 7 (MSB): bootable

   */

  unsigned char flags;

  char id[3];

  uint32_t start;

  uint32_t size;

} __attribute__((packed));

struct atari_rootsector {

  char unused0[0x156]; /* boot code */

  struct atari_part_def icd_part[8]; /* ICD partition entries */

  char unused1[0xc];

  uint32_t hd_size;

  struct atari_part_def part[4]; /* primary partition entries */

  uint32_t bsl_start; /* bad sector list start */

  uint32_t bsl_len; /* bad sector list length */

  uint16_t checksum;

} __attribute__((packed));

/*

 * Generated using linux kernel ctype.{c,h}

 *

 * Since kernel uses isalnum() to detect whether it is Atari PT, we need same

 * definition of alnum character to be consistent with kernel.

 */

static const unsigned char _linux_isalnum[] = {

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,

0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,

0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,

1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1

};

static int linux_isalnum(unsigned char c) {

  return _linux_isalnum[c];

}

#define isalnum linux_isalnum

#define IS_ACTIVE(partdef) ((partdef).flags & 1)

static int is_valid_dimension(uint32_t start, uint32_t size, uint32_t maxoff)

{

  uint64_t end = start + size;

  return  end >= start

    && 0 < start && start <= maxoff

    && 0 < size && size <= maxoff

    && 0 < end && end <= maxoff;

}

static int is_valid_partition(struct atari_part_def *part, uint32_t maxoff)

{

  uint32_t start = be32_to_cpu(part->start),

     size = be32_to_cpu(part->size);

  return (part->flags & 1)

    && isalnum(part->id[0])

    && isalnum(part->id[1])

    && isalnum(part->id[2])

    && is_valid_dimension(start, size, maxoff);

}

static int is_id_common(char *id)

{

  const char *ids[] = {"GEM", "BGM", "LNX", "SWP", "RAW", };

  unsigned i;

  for (i = 0; i < ARRAY_SIZE(ids); i++) {

    if (!memcmp(ids[i], id, 3))

      return 1;

  }

  return 0;

}

static int parse_partition(blkid_partlist ls, blkid_parttable tab,

  struct atari_part_def *part, uint32_t offset)

{

  blkid_partition par;

  uint32_t start;

  uint32_t size;

  start = be32_to_cpu(part->start) + offset;

  size = be32_to_cpu(part->size);

  if (blkid_partlist_get_partition_by_start(ls, start)) {

    /* Don't increment partno for extended parts */

    if (!offset)

      blkid_partlist_increment_partno(ls);

    return 0;

  }

  par = blkid_partlist_add_partition(ls, tab, start, size);

  if (!par)

    return -ENOMEM;

  blkid_partition_set_type_string(par, (unsigned char *) part->id,

          sizeof(part->id));

  return 1;

}

/*

 * \return 1: OK, 0: bad format or -errno

 */

static int parse_extended(blkid_probe pr, blkid_partlist ls,

  blkid_parttable tab, struct atari_part_def *part)

{

  uint32_t x0start, xstart;

  unsigned ct = 0, i = 0;

  int rc;

  x0start = xstart = be32_to_cpu(part->start);

  while (1) {

    struct atari_rootsector *xrs;

    if (++ct > 100)

      break;

    xrs = (struct atari_rootsector *) blkid_probe_get_sector(pr, xstart);

    if (!xrs) {

      if (errno)

        return -errno;

      return 0;

    }

    /*

     * There must be data partition followed by reference to next

     * XGM or inactive entry.

     */

    for (i=0; ; i++) {

      if (i >= ARRAY_SIZE(xrs->part) - 1)

        return 0;

      if (IS_ACTIVE(xrs->part[i]))

        break;

    }

    if (!memcmp(xrs->part[i].id, "XGM", 3))

      return 0;

    rc = parse_partition(ls, tab, &xrs->part[i], xstart);

    if (rc <= 0)

      return rc;

    if (!IS_ACTIVE(xrs->part[i+1]))

      break;

    if (memcmp(xrs->part[i+1].id, "XGM", 3) != 0)

      return 0;

    xstart = x0start + be32_to_cpu(xrs->part[i+1].start);

  }

  return 1;

}

static int probe_atari_pt(blkid_probe pr,

    const struct blkid_idmag *mag __attribute__((__unused__)))

{

  struct atari_rootsector *rs;

  blkid_parttable tab = NULL;

  blkid_partlist ls;

  unsigned i;

  int has_xgm = 0;

  int rc = 0;

  uint32_t rssize;  /* size in sectors from root sector */

  uint64_t size;    /* size in sectors from system */

  /* Atari partition is not defined for other sector sizes */

  if (blkid_probe_get_sectorsize(pr) != 512)

    goto nothing;

  size = blkid_probe_get_size(pr) / 512;

  /* Atari is not well defined to support large disks */

  if (size > INT32_MAX)

    goto nothing;

  /* read root sector */

  rs = (struct atari_rootsector *) blkid_probe_get_sector(pr, 0);

  if (!rs) {

    if (errno)

      return -errno;

    goto nothing;

  }

  rssize = be32_to_cpu(rs->hd_size);

  /* check number of sectors stored in the root sector */

  if (rssize < 2 || rssize > size)

    goto nothing;

  /* check list of bad blocks */

  if ((rs->bsl_start || rs->bsl_len)

      && !is_valid_dimension(be32_to_cpu(rs->bsl_start),

           be32_to_cpu(rs->bsl_len),

           rssize))

    goto nothing;

  /*

   * At least one valid partition required

   */

  for (i = 0; i < 4; i++) {

    if (is_valid_partition(&rs->part[i], rssize)) {

      if (blkid_probe_set_magic(pr,

          offsetof(struct atari_rootsector, part[i]),

          sizeof(rs->part[i].flags) + sizeof(rs->part[i].id),

          (unsigned char *) &rs->part[i]))

        goto err;

      break;

    }

  }

  if (i == 4)

    goto nothing;

  if (blkid_partitions_need_typeonly(pr))

    /* caller does not ask for details about partitions */

    return BLKID_PROBE_OK;

  ls = blkid_probe_get_partlist(pr);

  if (!ls)

    goto nothing;

  tab = blkid_partlist_new_parttable(ls, "atari", 0);

  if (!tab)

    goto err;

  for (i = 0; i < ARRAY_SIZE(rs->part); i++) {

    struct atari_part_def *p = &rs->part[i];

    if (!IS_ACTIVE(*p)) {

      blkid_partlist_increment_partno(ls);

      continue;

    }

    if (!memcmp(p->id, "XGM", 3)) {

      has_xgm = 1;

      rc = parse_extended(pr, ls, tab, p);

    } else {

      rc = parse_partition(ls, tab, p, 0);

    }

    if (rc < 0)

      return rc;

  }

  /* if there are no XGM partitions, we can try ICD format */

  /* if first ICD partition ID is not valid, assume no ICD format */

  if (!has_xgm && is_id_common(rs->icd_part[0].id)) {

    for (i = 0; i < ARRAY_SIZE(rs->icd_part); i++) {

      struct atari_part_def *p = &rs->icd_part[i];

      if (!IS_ACTIVE(*p) || !is_id_common(p->id)) {

        blkid_partlist_increment_partno(ls);

        continue;

      }

      rc = parse_partition(ls, tab, p, 0);

      if (rc < 0)

        return rc;

    }

  }

  return BLKID_PROBE_OK;

nothing:

  return BLKID_PROBE_NONE;

err:

  return -ENOMEM;

}

const struct blkid_idinfo atari_pt_idinfo =

{

  .name   = "atari",

  .probefunc  = probe_atari_pt,

  .magics   = BLKID_NONE_MAGIC

};