static int check_part_gpt(disk_t *disk, const int verbose,partition_t *partition, const int saveheader)
{
int ret=0;
unsigned int old_levels;
old_levels=log_set_levels(0);
if(guid_cmp(partition->part_type_gpt, GPT_ENT_TYPE_MS_BASIC_DATA)==0 ||
guid_cmp(partition->part_type_gpt, GPT_ENT_TYPE_MS_RESERVED)==0)
{
ret=check_FAT(disk,partition,verbose);
if(ret!=0)
ret=check_EXFAT(disk, partition);
if(ret!=0)
ret=check_NTFS(disk,partition,verbose,0);
if(ret!=0)
ret=check_ReFS(disk, partition);
if(ret!=0)
ret=check_linux(disk, partition, verbose);
if(ret!=0)
screen_buffer_add("No FAT, NTFS, ext2, JFS, Reiser, cramfs or XFS marker\n");
}
else if(guid_cmp(partition->part_type_gpt, GPT_ENT_TYPE_LINUX_RAID)==0)
{
ret=check_MD(disk, partition, verbose);
if(ret!=0)
screen_buffer_add("Invalid RAID superblock\n");
}
else if(guid_cmp(partition->part_type_gpt, GPT_ENT_TYPE_LINUX_LVM)==0)
{
ret=check_LVM(disk, partition, verbose);
if(ret!=0)
ret=check_LVM2(disk, partition, verbose);
if(ret!=0)
screen_buffer_add("No LVM or LVM2 structure\n");
}
else if(guid_cmp(partition->part_type_gpt, GPT_ENT_TYPE_MAC_HFS)==0)
{
ret=check_HFS(disk, partition, verbose);
if(ret!=0)
ret=check_HFSP(disk, partition, verbose);
if(ret!=0)
screen_buffer_add("No HFS or HFS+ structure\n");
}
log_set_levels(old_levels);
if(ret!=0)
{
log_error("check_part_gpt failed for partition\n");
log_partition(disk, partition);
aff_part_buffer(AFF_PART_ORDER|AFF_PART_STATUS,disk,partition);
if(saveheader>0)
{
save_header(disk, partition, verbose);
}
}
return ret;
}
int interface_superblock(disk_t *disk_car,list_part_t *list_part, char**current_cmd)
{
const list_part_t *parts;
const partition_t *old_part=NULL;
#ifdef HAVE_NCURSES
struct MenuItem menuSuperblock[]=
{
{ 'P', "Previous",""},
{ 'N', "Next","" },
{ 'Q',"Quit","Return to Advanced menu"},
{ 0, NULL, NULL }
};
#endif
screen_buffer_reset();
#ifdef HAVE_NCURSES
aff_copy(stdscr);
wmove(stdscr,4,0);
wprintw(stdscr,"%s",disk_car->description(disk_car));
wmove(stdscr,5,0);
mvwaddstr(stdscr,6,0,msg_PART_HEADER_LONG);
#endif
for(parts=list_part;parts!=NULL;parts=parts->next)
{
const partition_t *partition=parts->part;
if(old_part==NULL ||
old_part->part_offset!=partition->part_offset ||
old_part->part_size!=partition->part_size ||
guid_cmp(old_part->part_type_gpt, partition->part_type_gpt)!=0 ||
old_part->part_type_i386!=partition->part_type_i386 ||
old_part->part_type_sun!=partition->part_type_sun ||
old_part->part_type_mac!=partition->part_type_mac ||
old_part->upart_type!=partition->upart_type)
{
aff_part_buffer(AFF_PART_BASE, disk_car, partition);
old_part=partition;
}
if(partition->blocksize!=0)
screen_buffer_add("superblock %lu, blocksize=%u [%s]\n",
(long unsigned)(partition->sb_offset/partition->blocksize),
partition->blocksize, partition->fsname);
}
if(list_part!=NULL)
{
const partition_t *partition=list_part->part;
screen_buffer_add("\n");
screen_buffer_add("To repair the filesystem using alternate superblock, run\n");
screen_buffer_add("fsck.ext%u -p -b superblock -B blocksize device\n",
(partition->upart_type==UP_EXT2?2:
(partition->upart_type==UP_EXT3?3:4)));
}
screen_buffer_to_log();
if(*current_cmd==NULL)
{
log_flush();
#ifdef HAVE_NCURSES
screen_buffer_display(stdscr,"",menuSuperblock);
#endif
}
return 0;
}
/*
* Clear existing diagnostic results for the specified diagnostic
* and optionally for the specified device.
*/
void diag_clear_results(const enum diagnostic_test type,
const NVM_BOOL clear_specific_device, const NVM_GUID device_guid)
{
int event_count;
PersistentStore *p_store = get_lib_store();
if (p_store)
{
db_get_event_count_by_event_type_type(p_store, type, &event_count);
struct db_event events[event_count];
db_get_events_by_event_type_type(p_store, type, events, event_count);
for (int i = 0; i < event_count; i++)
{
NVM_BOOL matched = 1;
// check for a matching guid is requested
if (clear_specific_device)
{
COMMON_GUID guid;
str_to_guid(events[i].guid, guid);
if (guid_cmp(guid, device_guid) != 1)
{
matched = 0;
}
}
if (matched)
{
db_delete_event_by_id(p_store, events[i].id);
}
}
}
}
void RpcServiceResponseTimeDialog::addDceRpcProgramVersion(_dcerpc_uuid_key *key)
{
if (guid_cmp(&(dce_name_to_uuid_key_[program_combo_->currentText()]->uuid), &(key->uuid))) return;
versions_ << key->ver;
std::sort(versions_.begin(), versions_.end());
}
static const char *get_gpt_typename(const efi_guid_t part_type_gpt)
{
int i;
for(i=0; gpt_sys_types[i].name!=NULL; i++)
if(guid_cmp(gpt_sys_types[i].part_type, part_type_gpt)==0)
return gpt_sys_types[i].name;
return NULL;
}
static list_part_t *init_part_order_gpt(const disk_t *disk_car, list_part_t *list_part)
{
list_part_t *element;
unsigned int order=1;
for(element=list_part;element!=NULL;element=element->next)
{
if(element->part->part_size>0 &&
guid_cmp(element->part->part_type_gpt, GPT_ENT_TYPE_UNUSED)!=0)
element->part->order=order++;
}
return list_part;
}
static void partition_generate_gpt_entry(struct gpt_ent* gpt_entry, const partition_t *partition, const disk_t *disk_car)
{
guid_cpy(&gpt_entry->ent_type, &partition->part_type_gpt);
gpt_entry->ent_lba_start=le64(partition->part_offset / disk_car->sector_size);
gpt_entry->ent_lba_end=le64((partition->part_offset + partition->part_size - 1) / disk_car->sector_size);
str2UCSle((uint16_t *)&gpt_entry->ent_name, partition->partname, sizeof(gpt_entry->ent_name)/2);
if(guid_cmp(partition->part_uuid, GPT_ENT_TYPE_UNUSED)!=0)
guid_cpy(&gpt_entry->ent_uuid, &partition->part_uuid);
else
efi_generate_uuid(&gpt_entry->ent_uuid);
gpt_entry->ent_attr=le64(0); /* May need fixing */
}
static int is_part_hfsp(const partition_t *partition)
{
switch(partition->part_type_i386)
{
case P_HFSP:
return 1;
}
switch(partition->part_type_mac)
{
case PMAC_HFS:
return 1;
}
if(guid_cmp(partition->part_type_gpt,GPT_ENT_TYPE_MAC_HFS)==0)
return 1;
return 0;
}
NVM_UINT16 wbem::logic::PostLayoutAddressDecoderLimitCheck::getSocketIdForDimm(NVM_GUID &guid)
{
LogEnterExit logging(__FUNCTION__, __FILE__, __LINE__);
NVM_UINT16 socketId = 0;
for (std::vector<struct device_discovery>::const_iterator iter = m_devices.begin();
iter != m_devices.end(); iter++)
{
if (guid_cmp(iter->guid, guid))
{
socketId = iter->socket_id;
break;
}
}
return socketId;
}
void RpcServiceResponseTimeDialog::setDceRpcUuidAndVersion(_e_guid_t *uuid, int version)
{
bool found = false;
for (int pi = 0; pi < program_combo_->count(); pi++) {
if (guid_cmp(uuid, &(dce_name_to_uuid_key_[program_combo_->itemText(pi)]->uuid)) == 0) {
program_combo_->setCurrentIndex(pi);
for (int vi = 0; vi < version_combo_->count(); vi++) {
if (version == (int) version_combo_->itemData(vi).toUInt()) {
version_combo_->setCurrentIndex(vi);
found = true;
break;
}
}
break;
}
}
if (found) fillTree();
}
static int is_part_known_gpt(const partition_t *partition)
{
return (guid_cmp(partition->part_type_gpt, GPT_ENT_TYPE_UNUSED)!=0);
}
list_part_t *add_partition_gpt_cli(disk_t *disk_car,list_part_t *list_part, char **current_cmd)
{
partition_t *new_partition=partition_new(&arch_gpt);
new_partition->part_offset=disk_car->sector_size;
new_partition->part_size=disk_car->disk_size-new_partition->part_offset;
while(*current_cmd[0]==',')
(*current_cmd)++;
while(1)
{
if(strncmp(*current_cmd,"s,",2)==0)
{
uint64_t part_offset;
(*current_cmd)+=2;
part_offset=new_partition->part_offset;
new_partition->part_offset=(uint64_t)ask_number_cli(
current_cmd,
new_partition->part_offset/disk_car->sector_size,
1,
(disk_car->disk_size-1)/disk_car->sector_size,
"Enter the starting sector ") *
(uint64_t)disk_car->sector_size;
new_partition->part_size=new_partition->part_size + part_offset - new_partition->part_offset;
}
else if(strncmp(*current_cmd,"S,",2)==0)
{
(*current_cmd)+=2;
new_partition->part_size=(uint64_t)ask_number_cli(
current_cmd,
(new_partition->part_offset+new_partition->part_size-1)/disk_car->sector_size,
new_partition->part_offset/disk_car->sector_size,
(disk_car->disk_size-1)/disk_car->sector_size,
"Enter the ending sector ") *
(uint64_t)disk_car->sector_size +
disk_car->sector_size - new_partition->part_offset;
}
else if(strncmp(*current_cmd,"T,",2)==0)
{
(*current_cmd)+=2;
change_part_type_cli(disk_car,new_partition,current_cmd);
}
else if(new_partition->part_size>0 && guid_cmp(new_partition->part_type_gpt, GPT_ENT_TYPE_UNUSED)!=0)
{
int insert_error=0;
list_part_t *new_list_part=insert_new_partition(list_part, new_partition, 0, &insert_error);
if(insert_error>0)
{
free(new_partition);
return new_list_part;
}
new_partition->status=STATUS_PRIM;
if(test_structure_gpt(list_part)!=0)
new_partition->status=STATUS_DELETED;
return new_list_part;
}
else
{
free(new_partition);
return list_part;
}
}
}
list_part_t *read_part_gpt(disk_t *disk_car, const int verbose, const int saveheader)
{
struct gpt_hdr *gpt;
struct gpt_ent* gpt_entries;
list_part_t *new_list_part=NULL;
unsigned int i;
uint32_t gpt_entries_size;
uint64_t gpt_entries_offset;
gpt=(struct gpt_hdr*)MALLOC(disk_car->sector_size);
screen_buffer_reset();
if((unsigned)disk_car->pread(disk_car, gpt, disk_car->sector_size, disk_car->sector_size) != disk_car->sector_size)
{
free(gpt);
return NULL;
}
if(memcmp(gpt->hdr_sig, GPT_HDR_SIG, 8)!=0)
{
screen_buffer_add("Bad GPT partition, invalid signature.\n");
free(gpt);
return NULL;
}
if(verbose>0)
{
log_info("hdr_size=%llu\n", (long long unsigned)le32(gpt->hdr_size));
log_info("hdr_lba_self=%llu\n", (long long unsigned)le64(gpt->hdr_lba_self));
log_info("hdr_lba_alt=%llu (expected %llu)\n",
(long long unsigned)le64(gpt->hdr_lba_alt),
(long long unsigned)((disk_car->disk_size-1)/disk_car->sector_size));
log_info("hdr_lba_start=%llu\n", (long long unsigned)le64(gpt->hdr_lba_start));
log_info("hdr_lba_end=%llu\n", (long long unsigned)le64(gpt->hdr_lba_end));
log_info("hdr_lba_table=%llu\n",
(long long unsigned)le64(gpt->hdr_lba_table));
log_info("hdr_entries=%llu\n", (long long unsigned)le32(gpt->hdr_entries));
log_info("hdr_entsz=%llu\n", (long long unsigned)le32(gpt->hdr_entsz));
}
/* Check header size */
if(le32(gpt->hdr_size)<92 || le32(gpt->hdr_size) > disk_car->sector_size)
{
screen_buffer_add("GPT: invalid header size.\n");
free(gpt);
return NULL;
}
{ /* CRC check */
uint32_t crc;
uint32_t origcrc;
origcrc=le32(gpt->hdr_crc_self);
gpt->hdr_crc_self=le32(0);
crc=get_crc32(gpt, le32(gpt->hdr_size), 0xFFFFFFFF)^0xFFFFFFFF;
if(crc!=origcrc)
{
screen_buffer_add("Bad GPT partition, invalid header checksum.\n");
free(gpt);
return NULL;
}
gpt->hdr_crc_self=le32(origcrc);
}
if(le64(gpt->hdr_lba_self)!=1)
{
screen_buffer_add("Bad GPT partition, invalid LBA self location.\n");
free(gpt);
return NULL;
}
if(le64(gpt->hdr_lba_start) >= le64(gpt->hdr_lba_end))
{
screen_buffer_add("Bad GPT partition, invalid LBA start/end location.\n");
free(gpt);
return NULL;
}
if(le32(gpt->hdr_revision)!=GPT_HDR_REVISION)
{
screen_buffer_add("GPT: Warning - not revision 1.0\n");
}
if(le32(gpt->__reserved)!=0)
{
screen_buffer_add("GPT: Warning - __reserved!=0\n");
}
if(le32(gpt->hdr_entries)==0 || le32(gpt->hdr_entries)>4096)
{
screen_buffer_add("GPT: invalid number (%u) of partition entries.\n",
(unsigned int)le32(gpt->hdr_entries));
free(gpt);
return NULL;
}
/* le32(gpt->hdr_entsz)==128 */
if(le32(gpt->hdr_entsz)%8!=0 || le32(gpt->hdr_entsz)<128 || le32(gpt->hdr_entsz)>4096)
{
screen_buffer_add("GPT: invalid partition entry size.\n");
free(gpt);
return NULL;
}
gpt_entries_size=le32(gpt->hdr_entries) * le32(gpt->hdr_entsz);
if(gpt_entries_size<16384)
{
screen_buffer_add("GPT: A minimum of 16,384 bytes of space must be reserved for the GUID Partition Entry array.\n");
free(gpt);
return NULL;
}
gpt_entries_offset=(uint64_t)le64(gpt->hdr_lba_table) * disk_car->sector_size;
if((uint64_t) le64(gpt->hdr_lba_self) + le32(gpt->hdr_size) - 1 >= gpt_entries_offset ||
gpt_entries_offset >= le64(gpt->hdr_lba_start) * disk_car->sector_size)
{
screen_buffer_add( "GPT: The primary GUID Partition Entry array must be located after the primary GUID Partition Table Header and end before the FirstUsableLBA.\n");
free(gpt);
return NULL;
}
gpt_entries=(struct gpt_ent*)MALLOC(gpt_entries_size);
if((unsigned)disk_car->pread(disk_car, gpt_entries, gpt_entries_size, gpt_entries_offset) != gpt_entries_size)
{
free(gpt_entries);
free(gpt);
return new_list_part;
}
{ /* CRC check */
uint32_t crc;
crc=get_crc32(gpt_entries, gpt_entries_size, 0xFFFFFFFF)^0xFFFFFFFF;
if(crc!=le32(gpt->hdr_crc_table))
{
screen_buffer_add("Bad GPT partition entries, invalid checksum.\n");
free(gpt_entries);
free(gpt);
return NULL;
}
}
for(i=0;i<le32(gpt->hdr_entries);i++)
{
const struct gpt_ent* gpt_entry;
gpt_entry=(const struct gpt_ent*)((const char*)gpt_entries + (unsigned long)i*le32(gpt->hdr_entsz));
if(guid_cmp(gpt_entry->ent_type, GPT_ENT_TYPE_UNUSED)!=0 &&
le64(gpt_entry->ent_lba_start) < le64(gpt_entry->ent_lba_end))
{
int insert_error=0;
partition_t *new_partition=partition_new(&arch_gpt);
new_partition->order=i+1;
guid_cpy(&new_partition->part_uuid, &gpt_entry->ent_uuid);
guid_cpy(&new_partition->part_type_gpt, &gpt_entry->ent_type);
new_partition->part_offset=(uint64_t)le64(gpt_entry->ent_lba_start)*disk_car->sector_size;
new_partition->part_size=(uint64_t)(le64(gpt_entry->ent_lba_end) -
le64(gpt_entry->ent_lba_start)+1) * disk_car->sector_size;
new_partition->status=STATUS_PRIM;
UCSle2str(new_partition->partname, (const uint16_t *)&gpt_entry->ent_name, sizeof(gpt_entry->ent_name)/2);
new_partition->arch->check_part(disk_car,verbose,new_partition,saveheader);
/* log_debug("%u ent_attr %08llx\n", new_partition->order, (long long unsigned)le64(gpt_entry->ent_attr)); */
aff_part_buffer(AFF_PART_ORDER|AFF_PART_STATUS,disk_car,new_partition);
new_list_part=insert_new_partition(new_list_part, new_partition, 0, &insert_error);
if(insert_error>0)
free(new_partition);
}
}
/* TODO: The backup GUID Partition Entry array must be
located after the LastUsableLBA and end before the backup GUID Partition Table Header.
*/
free(gpt_entries);
free(gpt);
return new_list_part;
}
/*!
* Helper method to convert library events into a vector of diagnostic result structures.
* Used by the DiagnosticCompletionRecordFactory class as well.
*/
int wbem::support::DiagnosticLogFactory::gatherDiagnosticResults(diagnosticResults_t *pResults)
throw (framework::Exception)
{
int count = 0;
// get all diagnostic events
struct event_filter filter;
memset(&filter, 0, sizeof (struct event_filter));
filter.filter_mask = NVM_FILTER_ON_TYPE;
filter.type = EVENT_TYPE_DIAG;
int total_count = nvm_get_event_count(&filter);
if (total_count < 0)
{
throw exception::NvmExceptionLibError(total_count);
}
if (total_count > 0)
{
struct event events[total_count];
total_count = nvm_get_events(&filter, events, total_count);
if (total_count < 0)
{
throw exception::NvmExceptionLibError(total_count);
}
for (int i = 0; i < total_count; i++)
{
bool matched = false;
// only add a new structure if the test is unique to the type and guid
// else another message and update the result
for (diagnosticResults_t::iterator iter = pResults->begin();
iter != pResults->end(); iter++)
{
if ((*iter).type == events[i].type)
{
// matched existing result - update data but do not count
if (guid_cmp((*iter).device_guid, events[i].guid))
{
matched = true;
// update id (if necessary)
if (events[i].event_id < (*iter).id)
{
(*iter).id = events[i].event_id;
}
// update overall result (if necessary)
if (events[i].diag_result > (*iter).result)
{
(*iter).result = events[i].diag_result;
}
// update time (if necessary)
if (events[i].time < (*iter).time)
{
(*iter).time = events[i].time;
}
// add message
(*iter).messages.push_back(buildDiagnosticResultMessage(&events[i]));
break;
}
}
}
// add new result
if (!matched)
{
count++;
// copy the event information into the diagnostic result struct
struct diagnosticResult diag;
diag.id = events[i].event_id;
diag.time = events[i].time;
diag.type = events[i].type;
memmove(diag.device_guid, events[i].guid, NVM_GUID_LEN);
diag.result = events[i].diag_result;
diag.messages.push_back(buildDiagnosticResultMessage(&events[i]));
pResults->push_back(diag);
}
} // end for
} // end if events
return count;
}
static void gpt_change_part_type(const disk_t *disk_car, partition_t *partition)
{
unsigned int offset=0;
unsigned int i,j;
unsigned int current_element_num=0;
log_info("gpt_change_part_type\n");
aff_copy(stdscr);
wmove(stdscr,4,0);
aff_part(stdscr, AFF_PART_ORDER|AFF_PART_STATUS, disk_car, partition);
wmove(stdscr,INTER_CHGTYPE_Y, INTER_CHGTYPE_X);
wattrset(stdscr, A_REVERSE);
wprintw(stdscr, "[ Proceed ]");
wattroff(stdscr, A_REVERSE);
/* By default, select the current type */
for(i=0;gpt_sys_types[i].name!=NULL;i++)
{
if(guid_cmp(partition->part_type_gpt, gpt_sys_types[i].part_type)==0)
{
current_element_num=i;
while(current_element_num >= offset+3*INTER_CHGTYPE)
offset++;
}
}
while(1)
{
wmove(stdscr,5,0);
wprintw(stdscr, "Please choose the partition type, press Enter when done.");
wmove(stdscr,5+1,1);
wclrtoeol(stdscr);
if(offset>0)
wprintw(stdscr, "Previous");
for(i=offset;gpt_sys_types[i].name!=NULL && (i-offset)<3*INTER_CHGTYPE;i++)
{
if(i-offset<INTER_CHGTYPE)
wmove(stdscr,5+2+i-offset,0);
else if(i-offset<2*INTER_CHGTYPE)
wmove(stdscr,5+2+i-offset-INTER_CHGTYPE,26);
else
wmove(stdscr,5+2+i-offset-2*INTER_CHGTYPE,52);
wclrtoeol(stdscr); /* before addstr for BSD compatibility */
if(i==current_element_num)
{
wattrset(stdscr, A_REVERSE);
wprintw(stdscr,">%s", gpt_sys_types[i].name);
wattroff(stdscr, A_REVERSE);
} else
{
wprintw(stdscr," %s", gpt_sys_types[i].name);
}
}
if(i-offset<INTER_CHGTYPE)
wmove(stdscr,5+2+i-offset,1);
else if(i-offset<2*INTER_CHGTYPE)
wmove(stdscr,5+2+i-offset-INTER_CHGTYPE,27);
else
wmove(stdscr,5+2+i-offset-2*INTER_CHGTYPE,53);
wclrtoeol(stdscr);
if(gpt_sys_types[i].name!=NULL)
wprintw(stdscr, "Next");
switch(wgetch(stdscr))
{
case 'p':
case 'P':
case KEY_UP:
if(current_element_num>0)
current_element_num--;
break;
case 'n':
case 'N':
case KEY_DOWN:
if(gpt_sys_types[current_element_num].name!=NULL && gpt_sys_types[current_element_num+1].name!=NULL)
current_element_num++;
break;
case KEY_LEFT:
if(current_element_num > INTER_CHGTYPE)
current_element_num-=INTER_CHGTYPE;
else
current_element_num=0;
break;
case KEY_PPAGE:
if(current_element_num > 3*INTER_CHGTYPE-1)
current_element_num-=3*INTER_CHGTYPE-1;
else
current_element_num=0;
break;
case KEY_RIGHT:
for(j=0;j<INTER_CHGTYPE;j++)
{
if(gpt_sys_types[current_element_num].name!=NULL && gpt_sys_types[current_element_num+1].name!=NULL)
current_element_num++;
}
break;
case KEY_NPAGE:
for(j=0;j<3*INTER_CHGTYPE;j++)
{
if(gpt_sys_types[current_element_num].name!=NULL && gpt_sys_types[current_element_num+1].name!=NULL)
current_element_num++;
}
break;
case 'Q':
case 'q':
case key_CR:
#ifdef PADENTER
case PADENTER:
#endif
guid_cpy(&partition->part_type_gpt, &gpt_sys_types[current_element_num].part_type);
return;
}
if(current_element_num<offset)
offset=current_element_num;
if(current_element_num >= offset+3*INTER_CHGTYPE)
offset=current_element_num-3*INTER_CHGTYPE+1;
}
}
list_part_t *add_partition_gpt_ncurses(disk_t *disk_car,list_part_t *list_part, char **current_cmd)
{
int position=0;
int done = FALSE;
partition_t *new_partition=partition_new(&arch_gpt);
new_partition->part_offset=disk_car->sector_size;
new_partition->part_size=disk_car->disk_size-disk_car->sector_size;
while (done==FALSE)
{
int command;
static struct MenuItem menuGeometry[]=
{
{ 's', "Sector", "Change starting sector" },
{ 'S', "Sector", "Change ending sector" },
{ 'T' ,"Type", "Change partition type"},
{ 'd', "Done", "" },
{ 0, NULL, NULL }
};
aff_copy(stdscr);
wmove(stdscr,4,0);
wprintw(stdscr,"%s",disk_car->description(disk_car));
wmove(stdscr,10, 0);
wclrtoeol(stdscr);
aff_part(stdscr, AFF_PART_BASE, disk_car, new_partition);
wmove(stdscr,INTER_GEOM_Y, INTER_GEOM_X);
wclrtoeol(stdscr);
wrefresh(stdscr);
command=wmenuSimple(stdscr,menuGeometry, position);
switch (command) {
case 's':
{
uint64_t part_offset;
part_offset=new_partition->part_offset;
wmove(stdscr, INTER_GEOM_Y, INTER_GEOM_X);
new_partition->part_offset=(uint64_t)ask_number(
new_partition->part_offset/disk_car->sector_size,
1,
(disk_car->disk_size-1)/disk_car->sector_size,
"Enter the starting sector ") *
(uint64_t)disk_car->sector_size;
new_partition->part_size=new_partition->part_size + part_offset - new_partition->part_offset;
position=1;
}
break;
case 'S':
wmove(stdscr, INTER_GEOM_Y, INTER_GEOM_X);
new_partition->part_size=(uint64_t)ask_number(
(new_partition->part_offset+new_partition->part_size-1)/disk_car->sector_size,
new_partition->part_offset/disk_car->sector_size,
(disk_car->disk_size-1)/disk_car->sector_size,
"Enter the ending sector ") *
(uint64_t)disk_car->sector_size +
disk_car->sector_size - new_partition->part_offset;
position=2;
break;
case 'T':
case 't':
change_part_type(disk_car,new_partition, current_cmd);
position=3;
break;
case key_ESC:
case 'd':
case 'D':
case 'q':
case 'Q':
done = TRUE;
break;
}
}
if(new_partition->part_size>0 && guid_cmp(new_partition->part_type_gpt, GPT_ENT_TYPE_UNUSED)!=0)
{
int insert_error=0;
list_part_t *new_list_part=insert_new_partition(list_part, new_partition, 0, &insert_error);
if(insert_error>0)
{
free(new_partition);
return new_list_part;
}
new_partition->status=STATUS_PRIM;
if(arch_gpt.test_structure(list_part)!=0)
new_partition->status=STATUS_DELETED;
return new_list_part;
}
free(new_partition);
return list_part;
}
