/*

    File: partnone.c

    Copyright (C) 1998-2007 Christophe GRENIER <grenier@cgsecurity.org>
  
    This software is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
  
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
  
    You should have received a copy of the GNU General Public License along
    with this program; if not, write the Free Software Foundation, Inc., 51
    Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

 */


#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#endif
#include <ctype.h>      /* tolower */
#include "types.h"
#include "common.h"
#include "testdisk.h"
#include "fnctdsk.h"
#include "analyse.h"
#include "lang.h"
#include "intrf.h"
#include "chgtype.h"
#include "savehdr.h"
#include "bfs.h"
#include "bsd.h"
#include "cramfs.h"
#include "ext2.h"
#include "fat.h"
#include "fatx.h"
#include "hfs.h"
#include "hfsp.h"
#include "jfs_superblock.h"
#include "jfs.h"
#include "lvm.h"
#include "md.h"
#include "netware.h"
#include "ntfs.h"
#include "rfs.h"
#include "sun.h"
#include "sysv.h"
#include "swap.h"
#include "ufs.h"
#include "xfs.h"
#include "log.h"

static int check_part_none(disk_t *disk_car, const int debug,partition_t *partition,const int saveheader);
static int get_geometry_from_nonembr(const unsigned char *buffer, const int debug, CHS_t *geometry);
static list_part_t *read_part_none(disk_t *disk_car, const int debug, const int saveheader);
static list_part_t *init_part_order_none(const disk_t *disk_car, list_part_t *list_part);
static list_part_t *add_partition_none(disk_t *disk_car,list_part_t *list_part, const int debug, char **current_cmd);
static void set_next_status_none(const disk_t *disk_car, partition_t *partition);
static int test_structure_none(list_part_t *list_part);
static int set_part_type_none(partition_t *partition, unsigned int part_type);
static int is_part_known_none(const partition_t *partition);
static void init_structure_none(const disk_t *disk_car,list_part_t *list_part, const int debug);
static const char *get_partition_name_none(const partition_t *partition);
static const char *get_partition_name_none_aux(const unsigned int part_type_none);
static unsigned int get_part_type_none(const partition_t *partition);

static const struct systypes none_sys_types[] = {
  {UP_BEOS,	"BeFS"},
  {UP_CRAMFS,	"CramFS"},
  {UP_EXT2,	"ext2"},
  {UP_EXT3,	"ext3"},
/*  {UP_EXTENDED,	"Extended"}, */
  {UP_FAT12,	"FAT12"},
  {UP_FAT16,	"FAT16"},
  {UP_FAT32,	"FAT32"},
  {UP_FREEBSD,	"FreeBSD"},
  {UP_HFS,	"HFS"},
  {UP_HFSP,	"HFS+"},
  {UP_HPFS,	"HPFS"},
  {UP_JFS,	"JFS"},
  {UP_LINSWAP,	"Linux SWAP"},
  {UP_LINSWAP2,	"Linux SWAP 2"},
  {UP_LVM,	"Linux LVM"},
  {UP_LVM2,	"Linux LVM2"},
  {UP_NETWARE,	"Netware"},
  {UP_NTFS,	"NTFS"},
  {UP_OPENBSD,	"OpenBSD"},
  {UP_OS2MB,	"OS2 Multiboot"},
  {UP_RAID,	"Linux RAID"},
  {UP_RFS,	"ReiserFS 3.5"},
  {UP_RFS2,	"ReiserFS 3.6"},
  {UP_RFS3,	"ReiserFS 3.x"},
  {UP_RFS4,	"ReiserFS 4"},
  {UP_SUN,	"Sun"},
  {UP_SYSV4,	"SysV 4"},
  {UP_UFS,	"UFS"},
  {UP_UFS2,	"UFS 2"},
  {UP_UNK,	"Unknown"},
  {UP_XFS,	"XFS"},
  {UP_XFS2,	"XFS 2"},
  {UP_XFS3,	"XFS 3"},
  {UP_XFS4,	"XFS 4"},
  { 0,NULL }
};

arch_fnct_t arch_none=
{
  .part_name="None",
  .part_name_option="partition_none",
  .msg_part_type=NULL,
  .read_part=read_part_none,
  .write_part=NULL,
  .init_part_order=init_part_order_none,
  .get_geometry_from_mbr=get_geometry_from_nonembr,
  .check_part=check_part_none,
  .write_MBR_code=NULL,
  .add_partition=add_partition_none,
  .set_prev_status=set_next_status_none,
  .set_next_status=set_next_status_none,
  .test_structure=test_structure_none,
  .set_part_type=set_part_type_none,
  .is_part_known=is_part_known_none,
  .init_structure=init_structure_none,
  .erase_list_part=NULL,
  .get_partition_name=get_partition_name_none,
  .get_part_type=get_part_type_none
};

static unsigned int get_part_type_none(const partition_t *partition)
{
  return partition->upart_type;
}

int get_geometry_from_nonembr(const unsigned char *buffer, const int debug, CHS_t *geometry)
{
  {
    /* Ugly hack to get geometry from FAT and NTFS */
    const struct fat_boot_sector *fat_header=(const struct fat_boot_sector *)buffer;
    if(le16(fat_header->marker)==0xAA55)
    {
      if(le16(fat_header->secs_track)>0 && le16(fat_header->secs_track)<=63 &&
	  le16(fat_header->heads)>0 && le16(fat_header->heads)<=255)
      {
	geometry->sector=le16(fat_header->secs_track);
	geometry->head=le16(fat_header->heads)-1;
      }
    }
  }
  return 0;
}

list_part_t *read_part_none(disk_t *disk_car, const int debug, const int saveheader)
{
  unsigned char *buffer_disk;
  list_part_t *list_part;
  partition_t *partition;
  partition_t *new_partition;
  int res;
  new_partition=partition_new();
  partition_reset(new_partition);
  new_partition->order=NO_ORDER;
  new_partition->part_offset=0;
  new_partition->part_size=disk_car->disk_size;
  new_partition->status=STATUS_PRIM;

  partition=partition_new();
  buffer_disk=MALLOC(16*DEFAULT_SECTOR_SIZE);
  res=search_type_128(buffer_disk,disk_car,partition,debug,0);
  if(res<=0)
    res=search_type_64(buffer_disk,disk_car,partition,debug,0);
  if(res<=0)
    res=search_type_16(buffer_disk,disk_car,partition,debug,0);
  if(res<=0)
    res=search_type_2(buffer_disk,disk_car,partition,debug,0);
  if(res<=0)
    res=search_type_1(buffer_disk,disk_car,partition,debug,0);
  if(res<=0)
    res=search_type_0(buffer_disk,disk_car,partition,debug,0);
  free(buffer_disk);
  if(res>0)
  { /* limited dup_partition_t */
    new_partition->boot_sector=partition->boot_sector;
    new_partition->upart_type=partition->upart_type;
    strncpy(new_partition->info,partition->info,sizeof(new_partition->info));
    strncpy(new_partition->name,partition->name,sizeof(new_partition->name));
    new_partition->arch=partition->arch;
  }
  aff_buffer(BUFFER_RESET,"Q");
  disk_car->arch->check_part(disk_car,debug,new_partition,saveheader);
  free(partition);
  list_part=insert_new_partition(NULL,new_partition);
  aff_part_buffer(AFF_PART_ORDER,disk_car,new_partition);
  return list_part;
}

static list_part_t *init_part_order_none(const disk_t *disk_car, list_part_t *list_part)
{
  return list_part;
}

static list_part_t *add_partition_none(disk_t *disk_car,list_part_t *list_part, const int debug, char **current_cmd)
{
  return list_part;
}

static void set_next_status_none(const disk_t *disk_car, partition_t *partition)
{
}

static int test_structure_none(list_part_t *list_part)
{
  return 0;
}

static int set_part_type_none(partition_t *partition, unsigned int part_type)
{
  partition->upart_type=part_type;
  return 0;
}

static int is_part_known_none(const partition_t *partition)
{
  return 1;
}

static void init_structure_none(const disk_t *disk_car,list_part_t *list_part, const int debug)
{
  list_part_t *element;
  for(element=list_part;element!=NULL;element=element->next)
  {
    element->part->status=STATUS_PRIM;
  }
}

static int check_part_none(disk_t *disk_car,const int debug,partition_t *partition, const int saveheader)
{
  int ret=0;
  switch(partition->upart_type)
  {
    case UP_BEOS:
      ret=check_BeFS(disk_car,partition,debug);
      break;
    case UP_CRAMFS:
	ret=check_cramfs(disk_car,partition,debug);
	break;
    case UP_EXT2:
    case UP_EXT3:
	ret=check_EXT2(disk_car,partition,debug);
	break;
    case UP_EXTENDED:
	break;
    case UP_FAT12:
    case UP_FAT16:
    case UP_FAT32:
      ret=check_FAT(disk_car,partition,debug);
      break;
    case UP_FATX:
      ret=check_FATX(disk_car,partition,debug);
      break;
    case UP_FREEBSD:
      ret=check_BSD(disk_car,partition,debug,BSD_MAXPARTITIONS);
      break;
    case UP_HFS:
      ret=check_HFS(disk_car,partition,debug);
      break;
    case UP_HFSP:
      ret=check_HFSP(disk_car,partition,debug);
      break;
    case UP_HPFS:
      ret=check_HPFS(disk_car,partition,debug);
      break;
    case UP_JFS:
      ret=check_JFS(disk_car,partition,debug);
      break;
    case UP_LINSWAP:
    case UP_LINSWAP2:
      ret=check_Linux_SWAP(disk_car,partition,debug);
      break;
    case UP_LVM:
      ret=check_LVM(disk_car,partition,debug);
      break;
    case UP_LVM2:
	ret=check_LVM2(disk_car,partition,debug);
      break;
    case UP_NETWARE:
      ret=check_netware(disk_car,partition,debug);
      break;
    case UP_NTFS:
      ret=check_NTFS(disk_car,partition,debug,0);
      if(ret!=0)
      { aff_buffer(BUFFER_ADD,"Invalid NTFS boot\n"); }
      break;
    case UP_OPENBSD:
      ret=check_BSD(disk_car,partition,debug,OPENBSD_MAXPARTITIONS);
      break;
    case UP_OS2MB:
      ret=check_OS2MB(disk_car,partition,debug);
      break;
    case UP_RAID:
      ret=check_MD(disk_car,partition,debug);
      if(ret!=0)
      { aff_buffer(BUFFER_ADD,"Invalid RAID superblock\n"); }
      break;
    case UP_RFS:
    case UP_RFS2:
    case UP_RFS3:
    case UP_RFS4:
	ret=check_rfs(disk_car,partition,debug);
	break;
    case UP_SUN:
	ret=check_sun_i386(disk_car,partition,debug);
	break;
    case UP_SYSV4:
	ret=check_sysv(disk_car,partition,debug);
	break;
    case UP_UFS:
    case UP_UFS2:
	ret=check_ufs(disk_car,partition,debug);
	break;
    case UP_XFS:
    case UP_XFS2:
    case UP_XFS3:
    case UP_XFS4:
	ret=check_xfs(disk_car,partition,debug);
      break;
    case UP_UNK:
      if(debug>0)
      {
	log_info("check_part_none %u type %02X: no test\n",partition->order,partition->upart_type);
      }
      break;
  }
  return ret;
}

static const char *get_partition_name_none_aux(const unsigned int part_type_none)
{
  int i;
  for (i=0; none_sys_types[i].name!=NULL; i++)
    if (none_sys_types[i].part_type == part_type_none)
      return none_sys_types[i].name;
  return NULL;
}

static const char *get_partition_name_none(const partition_t *partition)
{
  return get_partition_name_none_aux(partition->upart_type);
}