path: root/src/context.h

/*
 *  context.h: The internal state representation of nwipe.
 *
 *  Copyright Darik Horn <dajhorn-dban@vanadac.com>.
 *
 *  Modifications to original dwipe Copyright Andy Beverley <andy@andybev.com>
 *
 *  This program 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, version 2.
 *
 *  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 to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 */

#ifndef CONTEXT_H_
#define CONTEXT_H_

#include "prng.h"
#ifndef __HDDTEMP_H__
#include "hddtemp_scsi/hddtemp.h"
#endif /* __HDDTEMP_H__ */

typedef enum nwipe_device_t_ {
    NWIPE_DEVICE_UNKNOWN = 0,  // Unknown device.
    NWIPE_DEVICE_IDE,
    NWIPE_DEVICE_SCSI,
    NWIPE_DEVICE_COMPAQ,  // Unimplemented.
    NWIPE_DEVICE_USB,
    NWIPE_DEVICE_IEEE1394,  // Unimplemented.
    NWIPE_DEVICE_ATA,
    NWIPE_DEVICE_NVME,
    NWIPE_DEVICE_VIRT,
    NWIPE_DEVICE_SAS,
    NWIPE_DEVICE_MMC
} nwipe_device_t;

typedef enum nwipe_pass_t_ {
    NWIPE_PASS_NONE = 0,  // Not running.
    NWIPE_PASS_WRITE,  // Writing patterns to the device.
    NWIPE_PASS_VERIFY,  // Verifying a pass.
    NWIPE_PASS_FINAL_BLANK,  // Filling the device with zeros.
    NWIPE_PASS_FINAL_OPS2  // Special case for nwipe_ops2.
} nwipe_pass_t;

typedef enum nwipe_select_t_ {
    NWIPE_SELECT_NONE = 0,  // Unused.
    NWIPE_SELECT_TRUE,  // Wipe this device.
    NWIPE_SELECT_TRUE_PARENT,  // A parent of this device has been selected, so the wipe is implied.
    NWIPE_SELECT_FALSE,  // Do not wipe this device.
    NWIPE_SELECT_FALSE_CHILD,  // A child of this device has been selected, so we can't wipe this device.
    NWIPE_SELECT_DISABLED  // Do not wipe this device and do not allow it to be selected.
} nwipe_select_t;

#define NWIPE_KNOB_SPEEDRING_SIZE 30
#define NWIPE_KNOB_SPEEDRING_GRANULARITY 10

typedef struct nwipe_speedring_t_
{
    u64 bytes[NWIPE_KNOB_SPEEDRING_SIZE];
    u64 bytestotal;
    u64 byteslast;
    time_t times[NWIPE_KNOB_SPEEDRING_SIZE];
    time_t timestotal;
    time_t timeslast;
    u32 position;
} nwipe_speedring_t;

#define NWIPE_DEVICE_LABEL_LENGTH 200
#define NWIPE_DEVICE_SIZE_TXT_LENGTH 8

// Arbitrary length, so far most paths don't exceed about 25 characters
#define MAX_HWMON_PATH_LENGTH 100

// 20 chracters for serial number plus null Byte
#define NWIPE_SERIALNUMBER_LENGTH 20

typedef struct nwipe_context_t_
{
    /*
     * Device fields
     */
    int device_block_size;  // The soft block size reported by the device, as logical
    int device_sector_size;  // The logical sector size reported by libparted
    int device_phys_sector_size;  // The physical sector size reported by libparted
    int device_bus;  // The device bus number.
    int device_fd;  // The file descriptor of the device file being wiped.
    int device_host;  // The host number.
    struct hd_driveid device_id;  // The WIN_IDENTIFY data for IDE drives.
    int device_lun;  // The device logical unit number.
    int device_major;  // The major device number.
    int device_minor;  // The minor device number.
    int device_part;  // The device partition or slice number.
    char* device_name;  // The device file name.
    char device_name_without_path[100];
    char gui_device_name[100];
    unsigned long long device_size;  // The device size in bytes.
    u64 device_size_in_sectors;  // The device size in number of logical sectors, this may be 512 or 4096 sectors
    u64 device_size_in_512byte_sectors;  // The device size in number of 512byte sectors, irrespective of logical sector
                                         // size reported by libata
    unsigned long long bytes_erased;  // Irrespective of pass, this how much of the drive has been erased, CANNOT be
                                      // greater than device_size.
    char* device_size_text;  // The device size in a more (human)readable format.
    char device_size_txt[NWIPE_DEVICE_SIZE_TXT_LENGTH];  // The device size in a more (human)readable format.
    char* device_model;  // The model of the device.
    char device_label[NWIPE_DEVICE_LABEL_LENGTH];  // The label (name, model, size and serial) of the device.
    struct stat device_stat;  // The device file state from fstat().
    nwipe_device_t device_type;  // Indicates an IDE, SCSI, or Compaq SMART device in enumerated form (int)
    char device_type_str[14];  // Indicates an IDE, SCSI, USB etc as per nwipe_device_t but in ascii
    int device_is_ssd;  // 0 = no SSD, 1 = is a SSD
    char device_serial_no[NWIPE_SERIALNUMBER_LENGTH
                          + 1];  // Serial number(processed, 20 characters plus null termination) of the device.
    int device_target;  // The device target.

    u64 eta;  // The estimated number of seconds until method completion.
    int entropy_fd;  // The entropy source. Usually /dev/urandom.
    int pass_count;  // The number of passes performed by the working wipe method.
    u64 pass_done;  // The number of bytes that have already been i/o'd in this pass.
    u64 pass_errors;  // The number of errors across all passes.
    u64 pass_size;  // The total number of i/o bytes across all passes.
    nwipe_pass_t pass_type;  // The type of the current working pass.
    int pass_working;  // The current working pass.
    nwipe_prng_t* prng;  // The PRNG implementation.
    nwipe_entropy_t prng_seed;  // The random data that is used to seed the PRNG.
    void* prng_state;  // The private internal state of the PRNG.
    int result;  // The process return value.
    int round_count;  // The number of rounds requested by the user for the working wipe method.
    u64 round_done;  // The number of bytes that have already been i/o'd.
    u64 round_errors;  // The number of errors across all rounds.
    u64 round_size;  // The total number of i/o bytes across all rounds.
    double round_percent;  // The percentage complete across all rounds.
    int round_working;  // The current working round.
    nwipe_select_t select;  // Indicates whether this device should be wiped.
    int signal;  // Set when the child is killed by a signal.
    nwipe_speedring_t speedring;  // Ring buffer for computing the rolling throughput average.
    short sync_status;  // A flag to indicate when the method is syncing.
    pthread_t thread;  // The ID of the thread.
    u64 throughput;  // Average throughput in bytes per second.
    char throughput_txt[13];  // Human readable throughput.
    u64 verify_errors;  // The number of verification errors across all passes.
    int templ_has_hwmon_data;  // 0 = no hwmon data available, 1 = hwmon data available
    int templ_has_scsitemp_data;  // 0 = no scsitemp data available, 1 = scsitemp data available
    char temp1_path[MAX_HWMON_PATH_LENGTH];  // path to temperature variables /sys/class/hwmon/hwmonX/ etc.
    int temp1_crit;  // Critical high drive temperature, 1000000=unitialised, millidegree celsius.
    int temp1_highest;  // Historical highest temperature reached, 1000000=unitialised, millidegree celsius.
    int temp1_input;  // drive temperature, -1=unitialised. 1000000=unitialised, millidegree celsius.
    int temp1_lcrit;  // Critical low drive temperature, 1000000=unitialised, millidegree celsius.
    int temp1_lowest;  // Historically lowest temperature, 1000000=unitialised, millidegree celsius.
    int temp1_max;  // Maximum allowed temperature, 1000000=unitialised, millidegree celsius.
    int temp1_min;  // Minimum allowed temperature, 1000000=unitialised, millidegree celsius.
    int temp1_monitored_wipe_max;
    int temp1_monitored_wipe_min;
    int temp1_monitored_wipe_avg;
    int temp1_flash_rate;  // number relates to one tenth of a second, so 2 means a flash on and off = 0.4s
    int temp1_flash_rate_counter;  // used by the gui for timing the flash rate
    int temp1_flash_rate_status;  // 0=blank 1=visible
    time_t temp1_time;  // The time when temperature was last checked, seconds since epoch
    struct disk* templ_disk;  // Pointer to disk structure for hddtemp SCSI routines
    int wipe_status;  // Wipe finished = 0, wipe in progress = 1, wipe yet to start = -1.
    char wipe_status_txt[10];  // ERASED, FAILED, ABORTED, INSANITY
    int spinner_idx;  // Index into the spinner character array
    char spinner_character[1];  // The current spinner character
    double duration;  // Duration of the wipe in seconds
    char duration_str[20];  // The duration string in hh:mm:ss
    time_t start_time;  // Start time of wipe
    time_t end_time;  // End time of wipe
    u64 fsyncdata_errors;  // The number of fsyncdata errors across all passes.
    char PDF_filename[FILENAME_MAX];  // The filename of the PDF certificate/report.
    int HPA_status;  // 0 = No HPA found/disabled, 1 = HPA detected, 2 = Unknown, unable to checked,
                     // 3 = Not applicable to this device
    u64 HPA_reported_set;  // the 'HPA set' value reported hdparm -N, i.e the first value of n/n
    u64 HPA_reported_real;  // the 'HPA real' value reported hdparm -N, i.e the second value of n/n
    int DCO_status;  // 0 = No DCO found, 1 = DCO detected, 2 = Unknown, unable to checked
    u64 DCO_reported_real_max_sectors;  // real max sectors as reported by hdparm --dco-identify
    u64 DCO_reported_real_max_size;  // real max sectors in bytes
    u64 Calculated_real_max_size_in_bytes;  // This value is determined from all the possible variations for drives that
                                            // don't support DCO/HPA and those that do. Also drives that can't provide
                                            // HPA/DCO due to the chips they use (USB adapters)
    char DCO_reported_real_max_size_text[NWIPE_DEVICE_SIZE_TXT_LENGTH];  // real max size in human readable form i.e 1TB
    char Calculated_real_max_size_in_bytes_text[NWIPE_DEVICE_SIZE_TXT_LENGTH];  // calculated real max human readable
    u64 HPA_sectors;  // The size of the host protected area in sectors
    char HPA_size_text[NWIPE_DEVICE_SIZE_TXT_LENGTH];  // Human readable size bytes, KB, MB, GB ..
    int HPA_display_toggle_state;  // 0 or 1 Used to toggle between "[1TB] [ 33C]" and [HDA STATUS]
    time_t HPA_toggle_time;  // records a time, then if for instance 3 seconds has elapsed the display changes
    int test_use1;
    int test_use2;

    /*
     * Identity contains the raw serial number of the drive
     * (where applicable), however, for use within nwipe use the
     * processed serial_no[21] string above. To access serial no. use
     * c[i]->serial_no) and not c[i]->identity.serial_no);
     */
    struct hd_driveid identity;
} nwipe_context_t;

/*
 * We use 2 data structs to pass data between threads.
 * The first contains any required values.
 * Values cannot form part of the second array below, hence the need for this.
 */
typedef struct
{
    int nwipe_enumerated;  // The number of devices available.
    int nwipe_selected;  // The number of devices being wiped.
    time_t maxeta;  // The estimated runtime of the slowest device.
    u64 throughput;  // Total throughput.
    u64 errors;  // The combined number of errors of all processes.
    pthread_t* gui_thread;  // The ID of GUI thread.
} nwipe_misc_thread_data_t;

/*
 * The second points to the first structure, as well as the structure of all the devices
 */
typedef struct
{
    nwipe_context_t** c;  // Pointer to the nwipe context structure.
    nwipe_misc_thread_data_t* nwipe_misc_thread_data;  // Pointer to the misc structure above.
} nwipe_thread_data_ptr_t;

#endif /* CONTEXT_H_ */